???¨¤ JFIF    ?? C    !"$"$?? C  ?? p " ??     ??   ?¨²   ???? (% aA*?XYD?(J??E¡éRE,P€XYae?)(E¡è2€B¡èR£¤ BQ¡è¡é X?)X¡­€¡è? @ .............................................................................................................................................................................. ............................................................................. sound/firewire.h000064400000025413152640040150007663 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ #ifndef _SOUND_FIREWIRE_H_INCLUDED #define _SOUND_FIREWIRE_H_INCLUDED #include #include /* events can be read() from the hwdep device */ #define SNDRV_FIREWIRE_EVENT_LOCK_STATUS 0x000010cc #define SNDRV_FIREWIRE_EVENT_DICE_NOTIFICATION 0xd1ce004e #define SNDRV_FIREWIRE_EVENT_EFW_RESPONSE 0x4e617475 #define SNDRV_FIREWIRE_EVENT_DIGI00X_MESSAGE 0x746e736c #define SNDRV_FIREWIRE_EVENT_MOTU_NOTIFICATION 0x64776479 #define SNDRV_FIREWIRE_EVENT_TASCAM_CONTROL 0x7473636d #define SNDRV_FIREWIRE_EVENT_MOTU_REGISTER_DSP_CHANGE 0x4d545244 #define SNDRV_FIREWIRE_EVENT_FF400_MESSAGE 0x4f6c6761 struct snd_firewire_event_common { unsigned int type; /* SNDRV_FIREWIRE_EVENT_xxx */ }; struct snd_firewire_event_lock_status { unsigned int type; unsigned int status; /* 0/1 = unlocked/locked */ }; struct snd_firewire_event_dice_notification { unsigned int type; unsigned int notification; /* DICE-specific bits */ }; #define SND_EFW_TRANSACTION_USER_SEQNUM_MAX ((__u32)((__u16)~0) - 1) /* each field should be in big endian */ struct snd_efw_transaction { __be32 length; __be32 version; __be32 seqnum; __be32 category; __be32 command; __be32 status; __be32 params[0]; }; struct snd_firewire_event_efw_response { unsigned int type; __be32 response[0]; /* some responses */ }; struct snd_firewire_event_digi00x_message { unsigned int type; __u32 message; /* Digi00x-specific message */ }; struct snd_firewire_event_motu_notification { unsigned int type; __u32 message; /* MOTU-specific bits. */ }; struct snd_firewire_tascam_change { unsigned int index; __be32 before; __be32 after; }; struct snd_firewire_event_tascam_control { unsigned int type; struct snd_firewire_tascam_change changes[0]; }; struct snd_firewire_event_motu_register_dsp_change { unsigned int type; __u32 count; /* The number of changes. */ __u32 changes[]; /* Encoded event for change of register DSP. */ }; /** * struct snd_firewire_event_ff400_message - the container for message from Fireface 400 when * operating hardware knob. * * @type: Fixed to SNDRV_FIREWIRE_EVENT_FF400_MESSAGE. * @message_count: The number of messages. * @messages.message: The messages expressing hardware knob operation. * @messages.tstamp: The isochronous cycle at which the request subaction of asynchronous * transaction was sent to deliver the message. It has 16 bit unsigned integer * value. The higher 3 bits of value expresses the lower three bits of second * field in the format of CYCLE_TIME, up to 7. The rest 13 bits expresses cycle * field up to 7999. * * The structure expresses message transmitted by Fireface 400 when operating hardware knob. */ struct snd_firewire_event_ff400_message { unsigned int type; unsigned int message_count; struct { __u32 message; __u32 tstamp; } messages[]; }; union snd_firewire_event { struct snd_firewire_event_common common; struct snd_firewire_event_lock_status lock_status; struct snd_firewire_event_dice_notification dice_notification; struct snd_firewire_event_efw_response efw_response; struct snd_firewire_event_digi00x_message digi00x_message; struct snd_firewire_event_tascam_control tascam_control; struct snd_firewire_event_motu_notification motu_notification; struct snd_firewire_event_motu_register_dsp_change motu_register_dsp_change; struct snd_firewire_event_ff400_message ff400_message; }; #define SNDRV_FIREWIRE_IOCTL_GET_INFO _IOR('H', 0xf8, struct snd_firewire_get_info) #define SNDRV_FIREWIRE_IOCTL_LOCK _IO('H', 0xf9) #define SNDRV_FIREWIRE_IOCTL_UNLOCK _IO('H', 0xfa) #define SNDRV_FIREWIRE_IOCTL_TASCAM_STATE _IOR('H', 0xfb, struct snd_firewire_tascam_state) #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_METER _IOR('H', 0xfc, struct snd_firewire_motu_register_dsp_meter) #define SNDRV_FIREWIRE_IOCTL_MOTU_COMMAND_DSP_METER _IOR('H', 0xfd, struct snd_firewire_motu_command_dsp_meter) #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_PARAMETER _IOR('H', 0xfe, struct snd_firewire_motu_register_dsp_parameter) #define SNDRV_FIREWIRE_TYPE_DICE 1 #define SNDRV_FIREWIRE_TYPE_FIREWORKS 2 #define SNDRV_FIREWIRE_TYPE_BEBOB 3 #define SNDRV_FIREWIRE_TYPE_OXFW 4 #define SNDRV_FIREWIRE_TYPE_DIGI00X 5 #define SNDRV_FIREWIRE_TYPE_TASCAM 6 #define SNDRV_FIREWIRE_TYPE_MOTU 7 #define SNDRV_FIREWIRE_TYPE_FIREFACE 8 struct snd_firewire_get_info { unsigned int type; /* SNDRV_FIREWIRE_TYPE_xxx */ unsigned int card; /* same as fw_cdev_get_info.card */ unsigned char guid[8]; char device_name[16]; /* device node in /dev */ }; /* * SNDRV_FIREWIRE_IOCTL_LOCK prevents the driver from streaming. * Returns -EBUSY if the driver is already streaming. */ #define SNDRV_FIREWIRE_TASCAM_STATE_COUNT 64 struct snd_firewire_tascam_state { __be32 data[SNDRV_FIREWIRE_TASCAM_STATE_COUNT]; }; /* * In below MOTU models, software is allowed to control their DSP by accessing to registers. * - 828mk2 * - 896hd * - Traveler * - 8 pre * - Ultralite * - 4 pre * - Audio Express * * On the other hand, the status of DSP is split into specific messages included in the sequence of * isochronous packet. ALSA firewire-motu driver gathers the messages and allow userspace applications * to read it via ioctl. In 828mk2, 896hd, and Traveler, hardware meter for all of physical inputs * are put into the message, while one pair of physical outputs is selected. The selection is done by * LSB one byte in asynchronous write quadlet transaction to 0x'ffff'f000'0b2c. * * I note that V3HD/V4HD uses asynchronous transaction for the purpose. The destination address is * registered to 0x'ffff'f000'0b38 and '0b3c by asynchronous write quadlet request. The size of * message differs between 23 and 51 quadlets. For the case, the number of mixer bus can be extended * up to 12. */ #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT 24 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT 24 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT \ (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT + SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT) /** * struct snd_firewire_motu_register_dsp_meter - the container for meter information in DSP * controlled by register access * @data: Signal level meters. The mapping between position and input/output channel is * model-dependent. * * The structure expresses the part of DSP status for hardware meter. The u8 storage includes linear * value for audio signal level between 0x00 and 0x7f. */ struct snd_firewire_motu_register_dsp_meter { __u8 data[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT]; }; #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT 4 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT 20 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT 10 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT + 2) /** * snd_firewire_motu_register_dsp_parameter - the container for parameters of DSP controlled * by register access. * @mixer.source.gain: The gain of source to mixer. * @mixer.source.pan: The L/R balance of source to mixer. * @mixer.source.flag: The flag of source to mixer, including mute, solo. * @mixer.source.paired_balance: The L/R balance of paired source to mixer, only for 4 pre and * Audio Express. * @mixer.source.paired_width: The width of paired source to mixer, only for 4 pre and * Audio Express. * @mixer.output.paired_volume: The volume of paired output from mixer. * @mixer.output.paired_flag: The flag of paired output from mixer. * @output.main_paired_volume: The volume of paired main output. * @output.hp_paired_volume: The volume of paired hp output. * @output.hp_paired_assignment: The source assigned to paired hp output. * @output.reserved: Padding for 32 bit alignment for future extension. * @line_input.boost_flag: The flags of boost for line inputs, only for 828mk2 and Traveler. * @line_input.nominal_level_flag: The flags of nominal level for line inputs, only for 828mk2 and * Traveler. * @line_input.reserved: Padding for 32 bit alignment for future extension. * @input.gain_and_invert: The value including gain and invert for input, only for Ultralite, 4 pre * and Audio Express. * @input.flag: The flag of input; e.g. jack detection, phantom power, and pad, only for Ultralite, * 4 pre and Audio express. * @reserved: Padding so that the size of structure is kept to 512 byte, but for future extension. * * The structure expresses the set of parameters for DSP controlled by register access. */ struct snd_firewire_motu_register_dsp_parameter { struct { struct { __u8 gain[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 pan[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 paired_balance[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 paired_width[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; } source[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; struct { __u8 paired_volume[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; __u8 paired_flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; } output; } mixer; struct { __u8 main_paired_volume; __u8 hp_paired_volume; __u8 hp_paired_assignment; __u8 reserved[5]; } output; struct { __u8 boost_flag; __u8 nominal_level_flag; __u8 reserved[6]; } line_input; struct { __u8 gain_and_invert[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; } input; __u8 reserved[64]; }; /* * In below MOTU models, software is allowed to control their DSP by command in frame of * asynchronous transaction to 0x'ffff'0001'0000: * * - 828 mk3 (FireWire only and Hybrid) * - 896 mk3 (FireWire only and Hybrid) * - Ultralite mk3 (FireWire only and Hybrid) * - Traveler mk3 * - Track 16 * * On the other hand, the states of hardware meter is split into specific messages included in the * sequence of isochronous packet. ALSA firewire-motu driver gathers the message and allow userspace * application to read it via ioctl. */ #define SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT 400 /** * struct snd_firewire_motu_command_dsp_meter - the container for meter information in DSP * controlled by command * @data: Signal level meters. The mapping between position and signal channel is model-dependent. * * The structure expresses the part of DSP status for hardware meter. The 32 bit storage is * estimated to include IEEE 764 32 bit single precision floating point (binary32) value. It is * expected to be linear value (not logarithm) for audio signal level between 0.0 and +1.0. */ struct snd_firewire_motu_command_dsp_meter { float data[SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT]; }; #endif /* _SOUND_FIREWIRE_H_INCLUDED */ sound/usb_stream.h000064400000002327152640040150010212 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * Copyright (C) 2007, 2008 Karsten Wiese */ #ifndef __SOUND_USB_STREAM_H #define __SOUND_USB_STREAM_H #define USB_STREAM_INTERFACE_VERSION 2 #define SNDRV_USB_STREAM_IOCTL_SET_PARAMS \ _IOW('H', 0x90, struct usb_stream_config) struct usb_stream_packet { unsigned offset; unsigned length; }; struct usb_stream_config { unsigned version; unsigned sample_rate; unsigned period_frames; unsigned frame_size; }; struct usb_stream { struct usb_stream_config cfg; unsigned read_size; unsigned write_size; int period_size; unsigned state; int idle_insize; int idle_outsize; int sync_packet; unsigned insize_done; unsigned periods_done; unsigned periods_polled; struct usb_stream_packet outpacket[2]; unsigned inpackets; unsigned inpacket_head; unsigned inpacket_split; unsigned inpacket_split_at; unsigned next_inpacket_split; unsigned next_inpacket_split_at; struct usb_stream_packet inpacket[0]; }; enum usb_stream_state { usb_stream_invalid, usb_stream_stopped, usb_stream_sync0, usb_stream_sync1, usb_stream_ready, usb_stream_running, usb_stream_xrun, }; #endif /* __SOUND_USB_STREAM_H */ sound/hdsp.h000064400000004034152640040150007001 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ #ifndef __SOUND_HDSP_H #define __SOUND_HDSP_H /* * Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org) */ #ifdef __linux__ #include #endif #define HDSP_MATRIX_MIXER_SIZE 2048 enum HDSP_IO_Type { Digiface, Multiface, H9652, H9632, RPM, Undefined, }; struct hdsp_peak_rms { __u32 input_peaks[26]; __u32 playback_peaks[26]; __u32 output_peaks[28]; __u64 input_rms[26]; __u64 playback_rms[26]; /* These are only used for H96xx cards */ __u64 output_rms[26]; }; #define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms) struct hdsp_config_info { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char spdif_sync_check; unsigned char adatsync_sync_check; unsigned char adat_sync_check[3]; unsigned char spdif_in; unsigned char spdif_out; unsigned char spdif_professional; unsigned char spdif_emphasis; unsigned char spdif_nonaudio; unsigned int spdif_sample_rate; unsigned int system_sample_rate; unsigned int autosync_sample_rate; unsigned char system_clock_mode; unsigned char clock_source; unsigned char autosync_ref; unsigned char line_out; unsigned char passthru; unsigned char da_gain; unsigned char ad_gain; unsigned char phone_gain; unsigned char xlr_breakout_cable; unsigned char analog_extension_board; }; #define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info) struct hdsp_firmware { void *firmware_data; /* 24413 x 4 bytes */ }; #define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware) struct hdsp_version { enum HDSP_IO_Type io_type; unsigned short firmware_rev; }; #define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version) struct hdsp_mixer { unsigned short matrix[HDSP_MATRIX_MIXER_SIZE]; }; #define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer) struct hdsp_9632_aeb { int aebi; int aebo; }; #define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) #endif /* __SOUND_HDSP_H */ sound/compress_params.h000064400000040115152640040150011241 0ustar00/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) AND MIT) */ /* * compress_params.h - codec types and parameters for compressed data * streaming interface * * Copyright (C) 2011 Intel Corporation * Authors: Pierre-Louis Bossart * Vinod Koul * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * The definitions in this file are derived from the OpenMAX AL version 1.1 * and OpenMAX IL v 1.1.2 header files which contain the copyright notice below * and are licensed under the MIT license. * * Copyright (c) 2007-2010 The Khronos Group Inc. */ #ifndef __SND_COMPRESS_PARAMS_H #define __SND_COMPRESS_PARAMS_H #include /* AUDIO CODECS SUPPORTED */ #define MAX_NUM_CODECS 32 #define MAX_NUM_CODEC_DESCRIPTORS 32 #define MAX_NUM_BITRATES 32 #define MAX_NUM_SAMPLE_RATES 32 /* Codecs are listed linearly to allow for extensibility */ #define SND_AUDIOCODEC_PCM ((__u32) 0x00000001) #define SND_AUDIOCODEC_MP3 ((__u32) 0x00000002) #define SND_AUDIOCODEC_AMR ((__u32) 0x00000003) #define SND_AUDIOCODEC_AMRWB ((__u32) 0x00000004) #define SND_AUDIOCODEC_AMRWBPLUS ((__u32) 0x00000005) #define SND_AUDIOCODEC_AAC ((__u32) 0x00000006) #define SND_AUDIOCODEC_WMA ((__u32) 0x00000007) #define SND_AUDIOCODEC_REAL ((__u32) 0x00000008) #define SND_AUDIOCODEC_VORBIS ((__u32) 0x00000009) #define SND_AUDIOCODEC_FLAC ((__u32) 0x0000000A) #define SND_AUDIOCODEC_IEC61937 ((__u32) 0x0000000B) #define SND_AUDIOCODEC_G723_1 ((__u32) 0x0000000C) #define SND_AUDIOCODEC_G729 ((__u32) 0x0000000D) #define SND_AUDIOCODEC_BESPOKE ((__u32) 0x0000000E) #define SND_AUDIOCODEC_ALAC ((__u32) 0x0000000F) #define SND_AUDIOCODEC_APE ((__u32) 0x00000010) #define SND_AUDIOCODEC_MAX SND_AUDIOCODEC_APE /* * Profile and modes are listed with bit masks. This allows for a * more compact representation of fields that will not evolve * (in contrast to the list of codecs) */ #define SND_AUDIOPROFILE_PCM ((__u32) 0x00000001) /* MP3 modes are only useful for encoders */ #define SND_AUDIOCHANMODE_MP3_MONO ((__u32) 0x00000001) #define SND_AUDIOCHANMODE_MP3_STEREO ((__u32) 0x00000002) #define SND_AUDIOCHANMODE_MP3_JOINTSTEREO ((__u32) 0x00000004) #define SND_AUDIOCHANMODE_MP3_DUAL ((__u32) 0x00000008) #define SND_AUDIOPROFILE_AMR ((__u32) 0x00000001) /* AMR modes are only useful for encoders */ #define SND_AUDIOMODE_AMR_DTX_OFF ((__u32) 0x00000001) #define SND_AUDIOMODE_AMR_VAD1 ((__u32) 0x00000002) #define SND_AUDIOMODE_AMR_VAD2 ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_UNDEFINED ((__u32) 0x00000000) #define SND_AUDIOSTREAMFORMAT_CONFORMANCE ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_IF1 ((__u32) 0x00000002) #define SND_AUDIOSTREAMFORMAT_IF2 ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_FSF ((__u32) 0x00000008) #define SND_AUDIOSTREAMFORMAT_RTPPAYLOAD ((__u32) 0x00000010) #define SND_AUDIOSTREAMFORMAT_ITU ((__u32) 0x00000020) #define SND_AUDIOPROFILE_AMRWB ((__u32) 0x00000001) /* AMRWB modes are only useful for encoders */ #define SND_AUDIOMODE_AMRWB_DTX_OFF ((__u32) 0x00000001) #define SND_AUDIOMODE_AMRWB_VAD1 ((__u32) 0x00000002) #define SND_AUDIOMODE_AMRWB_VAD2 ((__u32) 0x00000004) #define SND_AUDIOPROFILE_AMRWBPLUS ((__u32) 0x00000001) #define SND_AUDIOPROFILE_AAC ((__u32) 0x00000001) /* AAC modes are required for encoders and decoders */ #define SND_AUDIOMODE_AAC_MAIN ((__u32) 0x00000001) #define SND_AUDIOMODE_AAC_LC ((__u32) 0x00000002) #define SND_AUDIOMODE_AAC_SSR ((__u32) 0x00000004) #define SND_AUDIOMODE_AAC_LTP ((__u32) 0x00000008) #define SND_AUDIOMODE_AAC_HE ((__u32) 0x00000010) #define SND_AUDIOMODE_AAC_SCALABLE ((__u32) 0x00000020) #define SND_AUDIOMODE_AAC_ERLC ((__u32) 0x00000040) #define SND_AUDIOMODE_AAC_LD ((__u32) 0x00000080) #define SND_AUDIOMODE_AAC_HE_PS ((__u32) 0x00000100) #define SND_AUDIOMODE_AAC_HE_MPS ((__u32) 0x00000200) /* AAC formats are required for encoders and decoders */ #define SND_AUDIOSTREAMFORMAT_MP2ADTS ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_MP4ADTS ((__u32) 0x00000002) #define SND_AUDIOSTREAMFORMAT_MP4LOAS ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_MP4LATM ((__u32) 0x00000008) #define SND_AUDIOSTREAMFORMAT_ADIF ((__u32) 0x00000010) #define SND_AUDIOSTREAMFORMAT_MP4FF ((__u32) 0x00000020) #define SND_AUDIOSTREAMFORMAT_RAW ((__u32) 0x00000040) #define SND_AUDIOPROFILE_WMA7 ((__u32) 0x00000001) #define SND_AUDIOPROFILE_WMA8 ((__u32) 0x00000002) #define SND_AUDIOPROFILE_WMA9 ((__u32) 0x00000004) #define SND_AUDIOPROFILE_WMA10 ((__u32) 0x00000008) #define SND_AUDIOPROFILE_WMA9_PRO ((__u32) 0x00000010) #define SND_AUDIOPROFILE_WMA9_LOSSLESS ((__u32) 0x00000020) #define SND_AUDIOPROFILE_WMA10_LOSSLESS ((__u32) 0x00000040) #define SND_AUDIOMODE_WMA_LEVEL1 ((__u32) 0x00000001) #define SND_AUDIOMODE_WMA_LEVEL2 ((__u32) 0x00000002) #define SND_AUDIOMODE_WMA_LEVEL3 ((__u32) 0x00000004) #define SND_AUDIOMODE_WMA_LEVEL4 ((__u32) 0x00000008) #define SND_AUDIOMODE_WMAPRO_LEVELM0 ((__u32) 0x00000010) #define SND_AUDIOMODE_WMAPRO_LEVELM1 ((__u32) 0x00000020) #define SND_AUDIOMODE_WMAPRO_LEVELM2 ((__u32) 0x00000040) #define SND_AUDIOMODE_WMAPRO_LEVELM3 ((__u32) 0x00000080) #define SND_AUDIOSTREAMFORMAT_WMA_ASF ((__u32) 0x00000001) /* * Some implementations strip the ASF header and only send ASF packets * to the DSP */ #define SND_AUDIOSTREAMFORMAT_WMA_NOASF_HDR ((__u32) 0x00000002) #define SND_AUDIOPROFILE_REALAUDIO ((__u32) 0x00000001) #define SND_AUDIOMODE_REALAUDIO_G2 ((__u32) 0x00000001) #define SND_AUDIOMODE_REALAUDIO_8 ((__u32) 0x00000002) #define SND_AUDIOMODE_REALAUDIO_10 ((__u32) 0x00000004) #define SND_AUDIOMODE_REALAUDIO_SURROUND ((__u32) 0x00000008) #define SND_AUDIOPROFILE_VORBIS ((__u32) 0x00000001) #define SND_AUDIOMODE_VORBIS ((__u32) 0x00000001) #define SND_AUDIOPROFILE_FLAC ((__u32) 0x00000001) /* * Define quality levels for FLAC encoders, from LEVEL0 (fast) * to LEVEL8 (best) */ #define SND_AUDIOMODE_FLAC_LEVEL0 ((__u32) 0x00000001) #define SND_AUDIOMODE_FLAC_LEVEL1 ((__u32) 0x00000002) #define SND_AUDIOMODE_FLAC_LEVEL2 ((__u32) 0x00000004) #define SND_AUDIOMODE_FLAC_LEVEL3 ((__u32) 0x00000008) #define SND_AUDIOMODE_FLAC_LEVEL4 ((__u32) 0x00000010) #define SND_AUDIOMODE_FLAC_LEVEL5 ((__u32) 0x00000020) #define SND_AUDIOMODE_FLAC_LEVEL6 ((__u32) 0x00000040) #define SND_AUDIOMODE_FLAC_LEVEL7 ((__u32) 0x00000080) #define SND_AUDIOMODE_FLAC_LEVEL8 ((__u32) 0x00000100) #define SND_AUDIOSTREAMFORMAT_FLAC ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_FLAC_OGG ((__u32) 0x00000002) /* IEC61937 payloads without CUVP and preambles */ #define SND_AUDIOPROFILE_IEC61937 ((__u32) 0x00000001) /* IEC61937 with S/PDIF preambles+CUVP bits in 32-bit containers */ #define SND_AUDIOPROFILE_IEC61937_SPDIF ((__u32) 0x00000002) /* * IEC modes are mandatory for decoders. Format autodetection * will only happen on the DSP side with mode 0. The PCM mode should * not be used, the PCM codec should be used instead. */ #define SND_AUDIOMODE_IEC_REF_STREAM_HEADER ((__u32) 0x00000000) #define SND_AUDIOMODE_IEC_LPCM ((__u32) 0x00000001) #define SND_AUDIOMODE_IEC_AC3 ((__u32) 0x00000002) #define SND_AUDIOMODE_IEC_MPEG1 ((__u32) 0x00000004) #define SND_AUDIOMODE_IEC_MP3 ((__u32) 0x00000008) #define SND_AUDIOMODE_IEC_MPEG2 ((__u32) 0x00000010) #define SND_AUDIOMODE_IEC_AACLC ((__u32) 0x00000020) #define SND_AUDIOMODE_IEC_DTS ((__u32) 0x00000040) #define SND_AUDIOMODE_IEC_ATRAC ((__u32) 0x00000080) #define SND_AUDIOMODE_IEC_SACD ((__u32) 0x00000100) #define SND_AUDIOMODE_IEC_EAC3 ((__u32) 0x00000200) #define SND_AUDIOMODE_IEC_DTS_HD ((__u32) 0x00000400) #define SND_AUDIOMODE_IEC_MLP ((__u32) 0x00000800) #define SND_AUDIOMODE_IEC_DST ((__u32) 0x00001000) #define SND_AUDIOMODE_IEC_WMAPRO ((__u32) 0x00002000) #define SND_AUDIOMODE_IEC_REF_CXT ((__u32) 0x00004000) #define SND_AUDIOMODE_IEC_HE_AAC ((__u32) 0x00008000) #define SND_AUDIOMODE_IEC_HE_AAC2 ((__u32) 0x00010000) #define SND_AUDIOMODE_IEC_MPEG_SURROUND ((__u32) 0x00020000) #define SND_AUDIOPROFILE_G723_1 ((__u32) 0x00000001) #define SND_AUDIOMODE_G723_1_ANNEX_A ((__u32) 0x00000001) #define SND_AUDIOMODE_G723_1_ANNEX_B ((__u32) 0x00000002) #define SND_AUDIOMODE_G723_1_ANNEX_C ((__u32) 0x00000004) #define SND_AUDIOPROFILE_G729 ((__u32) 0x00000001) #define SND_AUDIOMODE_G729_ANNEX_A ((__u32) 0x00000001) #define SND_AUDIOMODE_G729_ANNEX_B ((__u32) 0x00000002) /* */ /* VBR/CBR definitions */ #define SND_RATECONTROLMODE_CONSTANTBITRATE ((__u32) 0x00000001) #define SND_RATECONTROLMODE_VARIABLEBITRATE ((__u32) 0x00000002) /* Encoder options */ struct snd_enc_wma { __u32 super_block_align; /* WMA Type-specific data */ }; /** * struct snd_enc_vorbis - Vorbis encoder parameters * @quality: Sets encoding quality to n, between -1 (low) and 10 (high). * In the default mode of operation, the quality level is 3. * Normal quality range is 0 - 10. * @managed: Boolean. Set bitrate management mode. This turns off the * normal VBR encoding, but allows hard or soft bitrate constraints to be * enforced by the encoder. This mode can be slower, and may also be * lower quality. It is primarily useful for streaming. * @max_bit_rate: Enabled only if managed is TRUE * @min_bit_rate: Enabled only if managed is TRUE * @downmix: Boolean. Downmix input from stereo to mono (has no effect on * non-stereo streams). Useful for lower-bitrate encoding. * * These options were extracted from the OpenMAX IL spec and Gstreamer vorbisenc * properties * * For best quality users should specify VBR mode and set quality levels. */ struct snd_enc_vorbis { __s32 quality; __u32 managed; __u32 max_bit_rate; __u32 min_bit_rate; __u32 downmix; } __attribute__((packed, aligned(4))); /** * struct snd_enc_real - RealAudio encoder parameters * @quant_bits: number of coupling quantization bits in the stream * @start_region: coupling start region in the stream * @num_regions: number of regions value * * These options were extracted from the OpenMAX IL spec */ struct snd_enc_real { __u32 quant_bits; __u32 start_region; __u32 num_regions; } __attribute__((packed, aligned(4))); /** * struct snd_enc_flac - FLAC encoder parameters * @num: serial number, valid only for OGG formats * needs to be set by application * @gain: Add replay gain tags * * These options were extracted from the FLAC online documentation * at http://flac.sourceforge.net/documentation_tools_flac.html * * To make the API simpler, it is assumed that the user will select quality * profiles. Additional options that affect encoding quality and speed can * be added at a later stage if needed. * * By default the Subset format is used by encoders. * * TAGS such as pictures, etc, cannot be handled by an offloaded encoder and are * not supported in this API. */ struct snd_enc_flac { __u32 num; __u32 gain; } __attribute__((packed, aligned(4))); struct snd_enc_generic { __u32 bw; /* encoder bandwidth */ __s32 reserved[15]; /* Can be used for SND_AUDIOCODEC_BESPOKE */ } __attribute__((packed, aligned(4))); struct snd_dec_flac { __u16 sample_size; __u16 min_blk_size; __u16 max_blk_size; __u16 min_frame_size; __u16 max_frame_size; __u16 reserved; } __attribute__((packed, aligned(4))); struct snd_dec_wma { __u32 encoder_option; __u32 adv_encoder_option; __u32 adv_encoder_option2; __u32 reserved; } __attribute__((packed, aligned(4))); struct snd_dec_alac { __u32 frame_length; __u8 compatible_version; __u8 pb; __u8 mb; __u8 kb; __u32 max_run; __u32 max_frame_bytes; } __attribute__((packed, aligned(4))); struct snd_dec_ape { __u16 compatible_version; __u16 compression_level; __u32 format_flags; __u32 blocks_per_frame; __u32 final_frame_blocks; __u32 total_frames; __u32 seek_table_present; } __attribute__((packed, aligned(4))); union snd_codec_options { struct snd_enc_wma wma; struct snd_enc_vorbis vorbis; struct snd_enc_real real; struct snd_enc_flac flac; struct snd_enc_generic generic; struct snd_dec_flac flac_d; struct snd_dec_wma wma_d; struct snd_dec_alac alac_d; struct snd_dec_ape ape_d; } __attribute__((packed, aligned(4))); /** struct snd_codec_desc - description of codec capabilities * @max_ch: Maximum number of audio channels * @sample_rates: Sampling rates in Hz, use values like 48000 for this * @num_sample_rates: Number of valid values in sample_rates array * @bit_rate: Indexed array containing supported bit rates * @num_bitrates: Number of valid values in bit_rate array * @rate_control: value is specified by SND_RATECONTROLMODE defines. * @profiles: Supported profiles. See SND_AUDIOPROFILE defines. * @modes: Supported modes. See SND_AUDIOMODE defines * @formats: Supported formats. See SND_AUDIOSTREAMFORMAT defines * @min_buffer: Minimum buffer size handled by codec implementation * @reserved: reserved for future use * * This structure provides a scalar value for profiles, modes and stream * format fields. * If an implementation supports multiple combinations, they will be listed as * codecs with different descriptors, for example there would be 2 descriptors * for AAC-RAW and AAC-ADTS. * This entails some redundancy but makes it easier to avoid invalid * configurations. * */ struct snd_codec_desc { __u32 max_ch; __u32 sample_rates[MAX_NUM_SAMPLE_RATES]; __u32 num_sample_rates; __u32 bit_rate[MAX_NUM_BITRATES]; __u32 num_bitrates; __u32 rate_control; __u32 profiles; __u32 modes; __u32 formats; __u32 min_buffer; __u32 reserved[15]; } __attribute__((packed, aligned(4))); /** struct snd_codec * @id: Identifies the supported audio encoder/decoder. * See SND_AUDIOCODEC macros. * @ch_in: Number of input audio channels * @ch_out: Number of output channels. In case of contradiction between * this field and the channelMode field, the channelMode field * overrides. * @sample_rate: Audio sample rate of input data in Hz, use values like 48000 * for this. * @bit_rate: Bitrate of encoded data. May be ignored by decoders * @rate_control: Encoding rate control. See SND_RATECONTROLMODE defines. * Encoders may rely on profiles for quality levels. * May be ignored by decoders. * @profile: Mandatory for encoders, can be mandatory for specific * decoders as well. See SND_AUDIOPROFILE defines. * @level: Supported level (Only used by WMA at the moment) * @ch_mode: Channel mode for encoder. See SND_AUDIOCHANMODE defines * @format: Format of encoded bistream. Mandatory when defined. * See SND_AUDIOSTREAMFORMAT defines. * @align: Block alignment in bytes of an audio sample. * Only required for PCM or IEC formats. * @options: encoder-specific settings * @reserved: reserved for future use */ struct snd_codec { __u32 id; __u32 ch_in; __u32 ch_out; __u32 sample_rate; __u32 bit_rate; __u32 rate_control; __u32 profile; __u32 level; __u32 ch_mode; __u32 format; __u32 align; union snd_codec_options options; __u32 reserved[3]; } __attribute__((packed, aligned(4))); #endif sound/asequencer.h000064400000051160152640040150010200 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * Main header file for the ALSA sequencer * Copyright (c) 1998-1999 by Frank van de Pol * (c) 1998-1999 by Jaroslav Kysela */ #ifndef __SOUND_ASEQUENCER_H #define __SOUND_ASEQUENCER_H #include /** version of the sequencer */ #define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) /** * definition of sequencer event types */ /** system messages * event data type = #snd_seq_result */ #define SNDRV_SEQ_EVENT_SYSTEM 0 #define SNDRV_SEQ_EVENT_RESULT 1 /** note messages (channel specific) * event data type = #snd_seq_ev_note */ #define SNDRV_SEQ_EVENT_NOTE 5 #define SNDRV_SEQ_EVENT_NOTEON 6 #define SNDRV_SEQ_EVENT_NOTEOFF 7 #define SNDRV_SEQ_EVENT_KEYPRESS 8 /** control messages (channel specific) * event data type = #snd_seq_ev_ctrl */ #define SNDRV_SEQ_EVENT_CONTROLLER 10 #define SNDRV_SEQ_EVENT_PGMCHANGE 11 #define SNDRV_SEQ_EVENT_CHANPRESS 12 #define SNDRV_SEQ_EVENT_PITCHBEND 13 /**< from -8192 to 8191 */ #define SNDRV_SEQ_EVENT_CONTROL14 14 /**< 14 bit controller value */ #define SNDRV_SEQ_EVENT_NONREGPARAM 15 /**< 14 bit NRPN address + 14 bit unsigned value */ #define SNDRV_SEQ_EVENT_REGPARAM 16 /**< 14 bit RPN address + 14 bit unsigned value */ /** synchronisation messages * event data type = #snd_seq_ev_ctrl */ #define SNDRV_SEQ_EVENT_SONGPOS 20 /* Song Position Pointer with LSB and MSB values */ #define SNDRV_SEQ_EVENT_SONGSEL 21 /* Song Select with song ID number */ #define SNDRV_SEQ_EVENT_QFRAME 22 /* midi time code quarter frame */ #define SNDRV_SEQ_EVENT_TIMESIGN 23 /* SMF Time Signature event */ #define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */ /** timer messages * event data type = snd_seq_ev_queue_control */ #define SNDRV_SEQ_EVENT_START 30 /* midi Real Time Start message */ #define SNDRV_SEQ_EVENT_CONTINUE 31 /* midi Real Time Continue message */ #define SNDRV_SEQ_EVENT_STOP 32 /* midi Real Time Stop message */ #define SNDRV_SEQ_EVENT_SETPOS_TICK 33 /* set tick queue position */ #define SNDRV_SEQ_EVENT_SETPOS_TIME 34 /* set realtime queue position */ #define SNDRV_SEQ_EVENT_TEMPO 35 /* (SMF) Tempo event */ #define SNDRV_SEQ_EVENT_CLOCK 36 /* midi Real Time Clock message */ #define SNDRV_SEQ_EVENT_TICK 37 /* midi Real Time Tick message */ #define SNDRV_SEQ_EVENT_QUEUE_SKEW 38 /* skew queue tempo */ /** others * event data type = none */ #define SNDRV_SEQ_EVENT_TUNE_REQUEST 40 /* tune request */ #define SNDRV_SEQ_EVENT_RESET 41 /* reset to power-on state */ #define SNDRV_SEQ_EVENT_SENSING 42 /* "active sensing" event */ /** echo back, kernel private messages * event data type = any type */ #define SNDRV_SEQ_EVENT_ECHO 50 /* echo event */ #define SNDRV_SEQ_EVENT_OSS 51 /* OSS raw event */ /** system status messages (broadcast for subscribers) * event data type = snd_seq_addr */ #define SNDRV_SEQ_EVENT_CLIENT_START 60 /* new client has connected */ #define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 /* client has left the system */ #define SNDRV_SEQ_EVENT_CLIENT_CHANGE 62 /* client status/info has changed */ #define SNDRV_SEQ_EVENT_PORT_START 63 /* new port was created */ #define SNDRV_SEQ_EVENT_PORT_EXIT 64 /* port was deleted from system */ #define SNDRV_SEQ_EVENT_PORT_CHANGE 65 /* port status/info has changed */ /** port connection changes * event data type = snd_seq_connect */ #define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 /* ports connected */ #define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 /* ports disconnected */ /* 70-89: synthesizer events - obsoleted */ /** user-defined events with fixed length * event data type = any */ #define SNDRV_SEQ_EVENT_USR0 90 #define SNDRV_SEQ_EVENT_USR1 91 #define SNDRV_SEQ_EVENT_USR2 92 #define SNDRV_SEQ_EVENT_USR3 93 #define SNDRV_SEQ_EVENT_USR4 94 #define SNDRV_SEQ_EVENT_USR5 95 #define SNDRV_SEQ_EVENT_USR6 96 #define SNDRV_SEQ_EVENT_USR7 97 #define SNDRV_SEQ_EVENT_USR8 98 #define SNDRV_SEQ_EVENT_USR9 99 /* 100-118: instrument layer - obsoleted */ /* 119-129: reserved */ /* 130-139: variable length events * event data type = snd_seq_ev_ext * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) */ #define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) */ #define SNDRV_SEQ_EVENT_BOUNCE 131 /* error event */ /* 132-134: reserved */ #define SNDRV_SEQ_EVENT_USR_VAR0 135 #define SNDRV_SEQ_EVENT_USR_VAR1 136 #define SNDRV_SEQ_EVENT_USR_VAR2 137 #define SNDRV_SEQ_EVENT_USR_VAR3 138 #define SNDRV_SEQ_EVENT_USR_VAR4 139 /* 150-151: kernel events with quote - DO NOT use in user clients */ #define SNDRV_SEQ_EVENT_KERNEL_ERROR 150 #define SNDRV_SEQ_EVENT_KERNEL_QUOTE 151 /* obsolete */ /* 152-191: reserved */ /* 192-254: hardware specific events */ /* 255: special event */ #define SNDRV_SEQ_EVENT_NONE 255 typedef unsigned char snd_seq_event_type_t; /** event address */ struct snd_seq_addr { unsigned char client; /**< Client number: 0..255, 255 = broadcast to all clients */ unsigned char port; /**< Port within client: 0..255, 255 = broadcast to all ports */ }; /** port connection */ struct snd_seq_connect { struct snd_seq_addr sender; struct snd_seq_addr dest; }; #define SNDRV_SEQ_ADDRESS_UNKNOWN 253 /* unknown source */ #define SNDRV_SEQ_ADDRESS_SUBSCRIBERS 254 /* send event to all subscribed ports */ #define SNDRV_SEQ_ADDRESS_BROADCAST 255 /* send event to all queues/clients/ports/channels */ #define SNDRV_SEQ_QUEUE_DIRECT 253 /* direct dispatch */ /* event mode flag - NOTE: only 8 bits available! */ #define SNDRV_SEQ_TIME_STAMP_TICK (0<<0) /* timestamp in clock ticks */ #define SNDRV_SEQ_TIME_STAMP_REAL (1<<0) /* timestamp in real time */ #define SNDRV_SEQ_TIME_STAMP_MASK (1<<0) #define SNDRV_SEQ_TIME_MODE_ABS (0<<1) /* absolute timestamp */ #define SNDRV_SEQ_TIME_MODE_REL (1<<1) /* relative to current time */ #define SNDRV_SEQ_TIME_MODE_MASK (1<<1) #define SNDRV_SEQ_EVENT_LENGTH_FIXED (0<<2) /* fixed event size */ #define SNDRV_SEQ_EVENT_LENGTH_VARIABLE (1<<2) /* variable event size */ #define SNDRV_SEQ_EVENT_LENGTH_VARUSR (2<<2) /* variable event size - user memory space */ #define SNDRV_SEQ_EVENT_LENGTH_MASK (3<<2) #define SNDRV_SEQ_PRIORITY_NORMAL (0<<4) /* normal priority */ #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ #define SNDRV_SEQ_PRIORITY_MASK (1<<4) /* note event */ struct snd_seq_ev_note { unsigned char channel; unsigned char note; unsigned char velocity; unsigned char off_velocity; /* only for SNDRV_SEQ_EVENT_NOTE */ unsigned int duration; /* only for SNDRV_SEQ_EVENT_NOTE */ }; /* controller event */ struct snd_seq_ev_ctrl { unsigned char channel; unsigned char unused1, unused2, unused3; /* pad */ unsigned int param; signed int value; }; /* generic set of bytes (12x8 bit) */ struct snd_seq_ev_raw8 { unsigned char d[12]; /* 8 bit value */ }; /* generic set of integers (3x32 bit) */ struct snd_seq_ev_raw32 { unsigned int d[3]; /* 32 bit value */ }; /* external stored data */ struct snd_seq_ev_ext { unsigned int len; /* length of data */ void *ptr; /* pointer to data (note: maybe 64-bit) */ } __attribute__((packed)); struct snd_seq_result { int event; /* processed event type */ int result; }; struct snd_seq_real_time { unsigned int tv_sec; /* seconds */ unsigned int tv_nsec; /* nanoseconds */ }; typedef unsigned int snd_seq_tick_time_t; /* midi ticks */ union snd_seq_timestamp { snd_seq_tick_time_t tick; struct snd_seq_real_time time; }; struct snd_seq_queue_skew { unsigned int value; unsigned int base; }; /* queue timer control */ struct snd_seq_ev_queue_control { unsigned char queue; /* affected queue */ unsigned char pad[3]; /* reserved */ union { signed int value; /* affected value (e.g. tempo) */ union snd_seq_timestamp time; /* time */ unsigned int position; /* sync position */ struct snd_seq_queue_skew skew; unsigned int d32[2]; unsigned char d8[8]; } param; }; /* quoted event - inside the kernel only */ struct snd_seq_ev_quote { struct snd_seq_addr origin; /* original sender */ unsigned short value; /* optional data */ struct snd_seq_event *event; /* quoted event */ } __attribute__((packed)); /* sequencer event */ struct snd_seq_event { snd_seq_event_type_t type; /* event type */ unsigned char flags; /* event flags */ char tag; unsigned char queue; /* schedule queue */ union snd_seq_timestamp time; /* schedule time */ struct snd_seq_addr source; /* source address */ struct snd_seq_addr dest; /* destination address */ union { /* event data... */ struct snd_seq_ev_note note; struct snd_seq_ev_ctrl control; struct snd_seq_ev_raw8 raw8; struct snd_seq_ev_raw32 raw32; struct snd_seq_ev_ext ext; struct snd_seq_ev_queue_control queue; union snd_seq_timestamp time; struct snd_seq_addr addr; struct snd_seq_connect connect; struct snd_seq_result result; struct snd_seq_ev_quote quote; } data; }; /* * bounce event - stored as variable size data */ struct snd_seq_event_bounce { int err; struct snd_seq_event event; /* external data follows here. */ }; /* system information */ struct snd_seq_system_info { int queues; /* maximum queues count */ int clients; /* maximum clients count */ int ports; /* maximum ports per client */ int channels; /* maximum channels per port */ int cur_clients; /* current clients */ int cur_queues; /* current queues */ char reserved[24]; }; /* system running information */ struct snd_seq_running_info { unsigned char client; /* client id */ unsigned char big_endian; /* 1 = big-endian */ unsigned char cpu_mode; /* 4 = 32bit, 8 = 64bit */ unsigned char pad; /* reserved */ unsigned char reserved[12]; }; /* known client numbers */ #define SNDRV_SEQ_CLIENT_SYSTEM 0 /* internal client numbers */ #define SNDRV_SEQ_CLIENT_DUMMY 14 /* midi through */ #define SNDRV_SEQ_CLIENT_OSS 15 /* oss sequencer emulator */ /* client types */ typedef int __bitwise snd_seq_client_type_t; #define NO_CLIENT ((snd_seq_client_type_t) 0) #define USER_CLIENT ((snd_seq_client_type_t) 1) #define KERNEL_CLIENT ((snd_seq_client_type_t) 2) /* event filter flags */ #define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */ #define SNDRV_SEQ_FILTER_MULTICAST (1<<1) /* accept multicast messages */ #define SNDRV_SEQ_FILTER_BOUNCE (1<<2) /* accept bounce event in error */ #define SNDRV_SEQ_FILTER_USE_EVENT (1<<31) /* use event filter */ struct snd_seq_client_info { int client; /* client number to inquire */ snd_seq_client_type_t type; /* client type */ char name[64]; /* client name */ unsigned int filter; /* filter flags */ unsigned char multicast_filter[8]; /* multicast filter bitmap */ unsigned char event_filter[32]; /* event filter bitmap */ int num_ports; /* RO: number of ports */ int event_lost; /* number of lost events */ int card; /* RO: card number[kernel] */ int pid; /* RO: pid[user] */ char reserved[56]; /* for future use */ }; /* client pool size */ struct snd_seq_client_pool { int client; /* client number to inquire */ int output_pool; /* outgoing (write) pool size */ int input_pool; /* incoming (read) pool size */ int output_room; /* minimum free pool size for select/blocking mode */ int output_free; /* unused size */ int input_free; /* unused size */ char reserved[64]; }; /* Remove events by specified criteria */ #define SNDRV_SEQ_REMOVE_INPUT (1<<0) /* Flush input queues */ #define SNDRV_SEQ_REMOVE_OUTPUT (1<<1) /* Flush output queues */ #define SNDRV_SEQ_REMOVE_DEST (1<<2) /* Restrict by destination q:client:port */ #define SNDRV_SEQ_REMOVE_DEST_CHANNEL (1<<3) /* Restrict by channel */ #define SNDRV_SEQ_REMOVE_TIME_BEFORE (1<<4) /* Restrict to before time */ #define SNDRV_SEQ_REMOVE_TIME_AFTER (1<<5) /* Restrict to time or after */ #define SNDRV_SEQ_REMOVE_TIME_TICK (1<<6) /* Time is in ticks */ #define SNDRV_SEQ_REMOVE_EVENT_TYPE (1<<7) /* Restrict to event type */ #define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) /* Do not flush off events */ #define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) /* Restrict to events with given tag */ struct snd_seq_remove_events { unsigned int remove_mode; /* Flags that determine what gets removed */ union snd_seq_timestamp time; unsigned char queue; /* Queue for REMOVE_DEST */ struct snd_seq_addr dest; /* Address for REMOVE_DEST */ unsigned char channel; /* Channel for REMOVE_DEST */ int type; /* For REMOVE_EVENT_TYPE */ char tag; /* Tag for REMOVE_TAG */ int reserved[10]; /* To allow for future binary compatibility */ }; /* known port numbers */ #define SNDRV_SEQ_PORT_SYSTEM_TIMER 0 #define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE 1 /* port capabilities (32 bits) */ #define SNDRV_SEQ_PORT_CAP_READ (1<<0) /* readable from this port */ #define SNDRV_SEQ_PORT_CAP_WRITE (1<<1) /* writable to this port */ #define SNDRV_SEQ_PORT_CAP_SYNC_READ (1<<2) #define SNDRV_SEQ_PORT_CAP_SYNC_WRITE (1<<3) #define SNDRV_SEQ_PORT_CAP_DUPLEX (1<<4) #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ /* port type */ #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ #define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1) /* generic MIDI device */ #define SNDRV_SEQ_PORT_TYPE_MIDI_GM (1<<2) /* General MIDI compatible device */ #define SNDRV_SEQ_PORT_TYPE_MIDI_GS (1<<3) /* GS compatible device */ #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ /* other standards...*/ #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ #define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11) /* Sampling device (support sample download) */ #define SNDRV_SEQ_PORT_TYPE_SAMPLE (1<<12) /* Sampling device (sample can be downloaded at any time) */ /*...*/ #define SNDRV_SEQ_PORT_TYPE_HARDWARE (1<<16) /* driver for a hardware device */ #define SNDRV_SEQ_PORT_TYPE_SOFTWARE (1<<17) /* implemented in software */ #define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER (1<<18) /* generates sound */ #define SNDRV_SEQ_PORT_TYPE_PORT (1<<19) /* connects to other device(s) */ #define SNDRV_SEQ_PORT_TYPE_APPLICATION (1<<20) /* application (sequencer/editor) */ /* misc. conditioning flags */ #define SNDRV_SEQ_PORT_FLG_GIVEN_PORT (1<<0) #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) struct snd_seq_port_info { struct snd_seq_addr addr; /* client/port numbers */ char name[64]; /* port name */ unsigned int capability; /* port capability bits */ unsigned int type; /* port type bits */ int midi_channels; /* channels per MIDI port */ int midi_voices; /* voices per MIDI port */ int synth_voices; /* voices per SYNTH port */ int read_use; /* R/O: subscribers for output (from this port) */ int write_use; /* R/O: subscribers for input (to this port) */ void *kernel; /* reserved for kernel use (must be NULL) */ unsigned int flags; /* misc. conditioning */ unsigned char time_queue; /* queue # for timestamping */ char reserved[59]; /* for future use */ }; /* queue flags */ #define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) /* sync enabled */ /* queue information */ struct snd_seq_queue_info { int queue; /* queue id */ /* * security settings, only owner of this queue can start/stop timer * etc. if the queue is locked for other clients */ int owner; /* client id for owner of the queue */ unsigned locked:1; /* timing queue locked for other queues */ char name[64]; /* name of this queue */ unsigned int flags; /* flags */ char reserved[60]; /* for future use */ }; /* queue info/status */ struct snd_seq_queue_status { int queue; /* queue id */ int events; /* read-only - queue size */ snd_seq_tick_time_t tick; /* current tick */ struct snd_seq_real_time time; /* current time */ int running; /* running state of queue */ int flags; /* various flags */ char reserved[64]; /* for the future */ }; /* queue tempo */ struct snd_seq_queue_tempo { int queue; /* sequencer queue */ unsigned int tempo; /* current tempo, us/tick */ int ppq; /* time resolution, ticks/quarter */ unsigned int skew_value; /* queue skew */ unsigned int skew_base; /* queue skew base */ char reserved[24]; /* for the future */ }; /* sequencer timer sources */ #define SNDRV_SEQ_TIMER_ALSA 0 /* ALSA timer */ #define SNDRV_SEQ_TIMER_MIDI_CLOCK 1 /* Midi Clock (CLOCK event) */ #define SNDRV_SEQ_TIMER_MIDI_TICK 2 /* Midi Timer Tick (TICK event) */ /* queue timer info */ struct snd_seq_queue_timer { int queue; /* sequencer queue */ int type; /* source timer type */ union { struct { struct snd_timer_id id; /* ALSA's timer ID */ unsigned int resolution; /* resolution in Hz */ } alsa; } u; char reserved[64]; /* for the future use */ }; struct snd_seq_queue_client { int queue; /* sequencer queue */ int client; /* sequencer client */ int used; /* queue is used with this client (must be set for accepting events) */ /* per client watermarks */ char reserved[64]; /* for future use */ }; #define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE (1<<0) /* exclusive connection */ #define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2) struct snd_seq_port_subscribe { struct snd_seq_addr sender; /* sender address */ struct snd_seq_addr dest; /* destination address */ unsigned int voices; /* number of voices to be allocated (0 = don't care) */ unsigned int flags; /* modes */ unsigned char queue; /* input time-stamp queue (optional) */ unsigned char pad[3]; /* reserved */ char reserved[64]; }; /* type of query subscription */ #define SNDRV_SEQ_QUERY_SUBS_READ 0 #define SNDRV_SEQ_QUERY_SUBS_WRITE 1 struct snd_seq_query_subs { struct snd_seq_addr root; /* client/port id to be searched */ int type; /* READ or WRITE */ int index; /* 0..N-1 */ int num_subs; /* R/O: number of subscriptions on this port */ struct snd_seq_addr addr; /* R/O: result */ unsigned char queue; /* R/O: result */ unsigned int flags; /* R/O: result */ char reserved[64]; /* for future use */ }; /* * IOCTL commands */ #define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int) #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status) #define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo) #define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo) #define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer) #define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer) #define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client) #define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client) #define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool) #define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool) #define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events) #define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs) #define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info) #endif /* __SOUND_ASEQUENCER_H */ sound/compress_offload.h000064400000013446152640040150011377 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * compress_offload.h - compress offload header definations * * Copyright (C) 2011 Intel Corporation * Authors: Vinod Koul * Pierre-Louis Bossart */ #ifndef __COMPRESS_OFFLOAD_H #define __COMPRESS_OFFLOAD_H #include #include #include #define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 2, 0) /** * struct snd_compressed_buffer - compressed buffer * @fragment_size: size of buffer fragment in bytes * @fragments: number of such fragments */ struct snd_compressed_buffer { __u32 fragment_size; __u32 fragments; } __attribute__((packed, aligned(4))); /** * struct snd_compr_params - compressed stream params * @buffer: buffer description * @codec: codec parameters * @no_wake_mode: dont wake on fragment elapsed */ struct snd_compr_params { struct snd_compressed_buffer buffer; struct snd_codec codec; __u8 no_wake_mode; } __attribute__((packed, aligned(4))); /** * struct snd_compr_tstamp - timestamp descriptor * @byte_offset: Byte offset in ring buffer to DSP * @copied_total: Total number of bytes copied from/to ring buffer to/by DSP * @pcm_frames: Frames decoded or encoded by DSP. This field will evolve by * large steps and should only be used to monitor encoding/decoding * progress. It shall not be used for timing estimates. * @pcm_io_frames: Frames rendered or received by DSP into a mixer or an audio * output/input. This field should be used for A/V sync or time estimates. * @sampling_rate: sampling rate of audio */ struct snd_compr_tstamp { __u32 byte_offset; __u32 copied_total; __u32 pcm_frames; __u32 pcm_io_frames; __u32 sampling_rate; } __attribute__((packed, aligned(4))); /** * struct snd_compr_avail - avail descriptor * @avail: Number of bytes available in ring buffer for writing/reading * @tstamp: timestamp information */ struct snd_compr_avail { __u64 avail; struct snd_compr_tstamp tstamp; } __attribute__((packed, aligned(4))); enum snd_compr_direction { SND_COMPRESS_PLAYBACK = 0, SND_COMPRESS_CAPTURE }; /** * struct snd_compr_caps - caps descriptor * @codecs: pointer to array of codecs * @direction: direction supported. Of type snd_compr_direction * @min_fragment_size: minimum fragment supported by DSP * @max_fragment_size: maximum fragment supported by DSP * @min_fragments: min fragments supported by DSP * @max_fragments: max fragments supported by DSP * @num_codecs: number of codecs supported * @reserved: reserved field */ struct snd_compr_caps { __u32 num_codecs; __u32 direction; __u32 min_fragment_size; __u32 max_fragment_size; __u32 min_fragments; __u32 max_fragments; __u32 codecs[MAX_NUM_CODECS]; __u32 reserved[11]; } __attribute__((packed, aligned(4))); /** * struct snd_compr_codec_caps - query capability of codec * @codec: codec for which capability is queried * @num_descriptors: number of codec descriptors * @descriptor: array of codec capability descriptor */ struct snd_compr_codec_caps { __u32 codec; __u32 num_descriptors; struct snd_codec_desc descriptor[MAX_NUM_CODEC_DESCRIPTORS]; } __attribute__((packed, aligned(4))); /** * enum sndrv_compress_encoder - encoder metadata key * @SNDRV_COMPRESS_ENCODER_PADDING: no of samples appended by the encoder at the * end of the track * @SNDRV_COMPRESS_ENCODER_DELAY: no of samples inserted by the encoder at the * beginning of the track */ enum sndrv_compress_encoder { SNDRV_COMPRESS_ENCODER_PADDING = 1, SNDRV_COMPRESS_ENCODER_DELAY = 2, }; /** * struct snd_compr_metadata - compressed stream metadata * @key: key id * @value: key value */ struct snd_compr_metadata { __u32 key; __u32 value[8]; } __attribute__((packed, aligned(4))); /* * compress path ioctl definitions * SNDRV_COMPRESS_GET_CAPS: Query capability of DSP * SNDRV_COMPRESS_GET_CODEC_CAPS: Query capability of a codec * SNDRV_COMPRESS_SET_PARAMS: Set codec and stream parameters * Note: only codec params can be changed runtime and stream params cant be * SNDRV_COMPRESS_GET_PARAMS: Query codec params * SNDRV_COMPRESS_TSTAMP: get the current timestamp value * SNDRV_COMPRESS_AVAIL: get the current buffer avail value. * This also queries the tstamp properties * SNDRV_COMPRESS_PAUSE: Pause the running stream * SNDRV_COMPRESS_RESUME: resume a paused stream * SNDRV_COMPRESS_START: Start a stream * SNDRV_COMPRESS_STOP: stop a running stream, discarding ring buffer content * and the buffers currently with DSP * SNDRV_COMPRESS_DRAIN: Play till end of buffers and stop after that * SNDRV_COMPRESS_IOCTL_VERSION: Query the API version */ #define SNDRV_COMPRESS_IOCTL_VERSION _IOR('C', 0x00, int) #define SNDRV_COMPRESS_GET_CAPS _IOWR('C', 0x10, struct snd_compr_caps) #define SNDRV_COMPRESS_GET_CODEC_CAPS _IOWR('C', 0x11,\ struct snd_compr_codec_caps) #define SNDRV_COMPRESS_SET_PARAMS _IOW('C', 0x12, struct snd_compr_params) #define SNDRV_COMPRESS_GET_PARAMS _IOR('C', 0x13, struct snd_codec) #define SNDRV_COMPRESS_SET_METADATA _IOW('C', 0x14,\ struct snd_compr_metadata) #define SNDRV_COMPRESS_GET_METADATA _IOWR('C', 0x15,\ struct snd_compr_metadata) #define SNDRV_COMPRESS_TSTAMP _IOR('C', 0x20, struct snd_compr_tstamp) #define SNDRV_COMPRESS_AVAIL _IOR('C', 0x21, struct snd_compr_avail) #define SNDRV_COMPRESS_PAUSE _IO('C', 0x30) #define SNDRV_COMPRESS_RESUME _IO('C', 0x31) #define SNDRV_COMPRESS_START _IO('C', 0x32) #define SNDRV_COMPRESS_STOP _IO('C', 0x33) #define SNDRV_COMPRESS_DRAIN _IO('C', 0x34) #define SNDRV_COMPRESS_NEXT_TRACK _IO('C', 0x35) #define SNDRV_COMPRESS_PARTIAL_DRAIN _IO('C', 0x36) /* * TODO * 1. add mmap support * */ #define SND_COMPR_TRIGGER_DRAIN 7 /*FIXME move this to pcm.h */ #define SND_COMPR_TRIGGER_NEXT_TRACK 8 #define SND_COMPR_TRIGGER_PARTIAL_DRAIN 9 #endif sound/emu10k1.h000064400000044610152640040150007232 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * Copyright (c) by Jaroslav Kysela , * Creative Labs, Inc. * Definitions for EMU10K1 (SB Live!) chips */ #ifndef __SOUND_EMU10K1_H #define __SOUND_EMU10K1_H #ifdef __linux__ #include #endif /* * ---- FX8010 ---- */ #define EMU10K1_FX8010_PCM_COUNT 8 /* * Following definition is copied from linux/types.h to support compiling * this header file in userspace since they are not generally available for * uapi headers. */ #define __EMU10K1_DECLARE_BITMAP(name,bits) \ unsigned long name[(bits) / (sizeof(unsigned long) * 8)] /* instruction set */ #define iMAC0 0x00 /* R = A + (X * Y >> 31) ; saturation */ #define iMAC1 0x01 /* R = A + (-X * Y >> 31) ; saturation */ #define iMAC2 0x02 /* R = A + (X * Y >> 31) ; wraparound */ #define iMAC3 0x03 /* R = A + (-X * Y >> 31) ; wraparound */ #define iMACINT0 0x04 /* R = A + X * Y ; saturation */ #define iMACINT1 0x05 /* R = A + X * Y ; wraparound (31-bit) */ #define iACC3 0x06 /* R = A + X + Y ; saturation */ #define iMACMV 0x07 /* R = A, acc += X * Y >> 31 */ #define iANDXOR 0x08 /* R = (A & X) ^ Y */ #define iTSTNEG 0x09 /* R = (A >= Y) ? X : ~X */ #define iLIMITGE 0x0a /* R = (A >= Y) ? X : Y */ #define iLIMITLT 0x0b /* R = (A < Y) ? X : Y */ #define iLOG 0x0c /* R = linear_data, A (log_data), X (max_exp), Y (format_word) */ #define iEXP 0x0d /* R = log_data, A (linear_data), X (max_exp), Y (format_word) */ #define iINTERP 0x0e /* R = A + (X * (Y - A) >> 31) ; saturation */ #define iSKIP 0x0f /* R = A (cc_reg), X (count), Y (cc_test) */ #define LOWORD_OPX_MASK 0x000ffc00 /* Instruction operand X */ #define LOWORD_OPY_MASK 0x000003ff /* Instruction operand Y */ #define HIWORD_OPCODE_MASK 0x00f00000 /* Instruction opcode */ #define HIWORD_RESULT_MASK 0x000ffc00 /* Instruction result */ #define HIWORD_OPA_MASK 0x000003ff /* Instruction operand A */ /* Audigy Soundcards have a different instruction format */ #define A_LOWORD_OPX_MASK 0x007ff000 #define A_LOWORD_OPY_MASK 0x000007ff #define A_HIWORD_OPCODE_MASK 0x0f000000 #define A_HIWORD_RESULT_MASK 0x007ff000 #define A_HIWORD_OPA_MASK 0x000007ff /* GPRs */ #define FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x0f */ #define EXTIN(x) (0x10 + (x)) /* x = 0x00 - 0x0f */ #define EXTOUT(x) (0x20 + (x)) /* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */ #define FXBUS2(x) (0x30 + (x)) /* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */ /* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */ #define A_FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x3f FX buses */ #define A_EXTIN(x) (0x40 + (x)) /* x = 0x00 - 0x0f physical ins */ #define A_P16VIN(x) (0x50 + (x)) /* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */ #define A_EXTOUT(x) (0x60 + (x)) /* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown */ #define A_FXBUS2(x) (0x80 + (x)) /* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */ #define A_EMU32OUTH(x) (0xa0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" */ #define A_EMU32OUTL(x) (0xb0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_01 - _0F" */ #define A3_EMU32IN(x) (0x160 + (x)) /* x = 0x00 - 0x1f "EMU32_IN_00 - _1F" - Only when .device = 0x0008 */ #define A3_EMU32OUT(x) (0x1E0 + (x)) /* x = 0x00 - 0x1f "EMU32_OUT_00 - _1F" - Only when .device = 0x0008 */ #define C_00000000 0x40 #define C_00000001 0x41 #define C_00000002 0x42 #define C_00000003 0x43 #define C_00000004 0x44 #define C_00000008 0x45 #define C_00000010 0x46 #define C_00000020 0x47 #define C_00000100 0x48 #define C_00010000 0x49 #define C_00080000 0x4a #define C_10000000 0x4b #define C_20000000 0x4c #define C_40000000 0x4d #define C_80000000 0x4e #define C_7fffffff 0x4f #define C_ffffffff 0x50 #define C_fffffffe 0x51 #define C_c0000000 0x52 #define C_4f1bbcdc 0x53 #define C_5a7ef9db 0x54 #define C_00100000 0x55 /* ?? */ #define GPR_ACCU 0x56 /* ACCUM, accumulator */ #define GPR_COND 0x57 /* CCR, condition register */ #define GPR_NOISE0 0x58 /* noise source */ #define GPR_NOISE1 0x59 /* noise source */ #define GPR_IRQ 0x5a /* IRQ register */ #define GPR_DBAC 0x5b /* TRAM Delay Base Address Counter */ /* Audigy constants */ #define A_C_00000000 0xc0 #define A_C_00000001 0xc1 #define A_C_00000002 0xc2 #define A_C_00000003 0xc3 #define A_C_00000004 0xc4 #define A_C_00000008 0xc5 #define A_C_00000010 0xc6 #define A_C_00000020 0xc7 #define A_C_00000100 0xc8 #define A_C_00010000 0xc9 #define A_C_00000800 0xca #define A_C_10000000 0xcb #define A_C_20000000 0xcc #define A_C_40000000 0xcd #define A_C_80000000 0xce #define A_C_7fffffff 0xcf #define A_C_ffffffff 0xd0 #define A_C_fffffffe 0xd1 #define A_C_c0000000 0xd2 #define A_C_4f1bbcdc 0xd3 #define A_C_5a7ef9db 0xd4 #define A_C_00100000 0xd5 #define A_GPR_ACCU 0xd6 /* ACCUM, accumulator */ #define A_GPR_COND 0xd7 /* CCR, condition register */ #define A_GPR_NOISE0 0xd8 /* noise source */ #define A_GPR_NOISE1 0xd9 /* noise source */ #define A_GPR_IRQ 0xda /* IRQ register */ #define A_GPR_DBAC 0xdb /* TRAM Delay Base Address Counter - internal */ #define A_GPR_DBACE 0xde /* TRAM Delay Base Address Counter - external */ /* Each FX general purpose register is 32 bits in length, all bits are used */ #define FXGPREGBASE 0x100 /* FX general purpose registers base */ #define A_FXGPREGBASE 0x400 /* Audigy GPRs, 0x400 to 0x5ff */ #define A_TANKMEMCTLREGBASE 0x100 /* Tank memory control registers base - only for Audigy */ #define A_TANKMEMCTLREG_MASK 0x1f /* only 5 bits used - only for Audigy */ /* Tank audio data is logarithmically compressed down to 16 bits before writing to TRAM and is */ /* decompressed back to 20 bits on a read. There are a total of 160 locations, the last 32 */ /* locations are for external TRAM. */ #define TANKMEMDATAREGBASE 0x200 /* Tank memory data registers base */ #define TANKMEMDATAREG_MASK 0x000fffff /* 20 bit tank audio data field */ /* Combined address field and memory opcode or flag field. 160 locations, last 32 are external */ #define TANKMEMADDRREGBASE 0x300 /* Tank memory address registers base */ #define TANKMEMADDRREG_ADDR_MASK 0x000fffff /* 20 bit tank address field */ #define TANKMEMADDRREG_CLEAR 0x00800000 /* Clear tank memory */ #define TANKMEMADDRREG_ALIGN 0x00400000 /* Align read or write relative to tank access */ #define TANKMEMADDRREG_WRITE 0x00200000 /* Write to tank memory */ #define TANKMEMADDRREG_READ 0x00100000 /* Read from tank memory */ #define GPR(x) (FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */ #define ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ #define ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ #define ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ #define ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ #define A_GPR(x) (A_FXGPREGBASE + (x)) #define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ #define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ #define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ #define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ #define A_ITRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ #define A_ETRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ /* cc_reg constants */ #define CC_REG_NORMALIZED C_00000001 #define CC_REG_BORROW C_00000002 #define CC_REG_MINUS C_00000004 #define CC_REG_ZERO C_00000008 #define CC_REG_SATURATE C_00000010 #define CC_REG_NONZERO C_00000100 #define A_CC_REG_NORMALIZED A_C_00000001 #define A_CC_REG_BORROW A_C_00000002 #define A_CC_REG_MINUS A_C_00000004 #define A_CC_REG_ZERO A_C_00000008 #define A_CC_REG_SATURATE A_C_00000010 #define A_CC_REG_NONZERO A_C_00000100 /* FX buses */ // These are arbitrary mappings; our DSP code simply expects // the config files to route the channels this way. // The numbers are documented in {audigy,sb-live}-mixer.rst. #define FXBUS_PCM_LEFT 0x00 #define FXBUS_PCM_RIGHT 0x01 #define FXBUS_PCM_LEFT_REAR 0x02 #define FXBUS_PCM_RIGHT_REAR 0x03 #define FXBUS_MIDI_LEFT 0x04 #define FXBUS_MIDI_RIGHT 0x05 #define FXBUS_PCM_CENTER 0x06 #define FXBUS_PCM_LFE 0x07 #define FXBUS_PCM_LEFT_FRONT 0x08 #define FXBUS_PCM_RIGHT_FRONT 0x09 #define FXBUS_MIDI_REVERB 0x0c #define FXBUS_MIDI_CHORUS 0x0d #define FXBUS_PCM_LEFT_SIDE 0x0e #define FXBUS_PCM_RIGHT_SIDE 0x0f #define FXBUS_PT_LEFT 0x14 #define FXBUS_PT_RIGHT 0x15 /* Inputs */ #define EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ #define EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ #define EXTIN_SPDIF_CD_L 0x02 /* internal S/PDIF CD - onboard - left */ #define EXTIN_SPDIF_CD_R 0x03 /* internal S/PDIF CD - onboard - right */ #define EXTIN_ZOOM_L 0x04 /* Zoom Video I2S - left */ #define EXTIN_ZOOM_R 0x05 /* Zoom Video I2S - right */ #define EXTIN_TOSLINK_L 0x06 /* LiveDrive - TOSLink Optical - left */ #define EXTIN_TOSLINK_R 0x07 /* LiveDrive - TOSLink Optical - right */ #define EXTIN_LINE1_L 0x08 /* LiveDrive - Line/Mic 1 - left */ #define EXTIN_LINE1_R 0x09 /* LiveDrive - Line/Mic 1 - right */ #define EXTIN_COAX_SPDIF_L 0x0a /* LiveDrive - Coaxial S/PDIF - left */ #define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */ #define EXTIN_LINE2_L 0x0c /* LiveDrive - Line/Mic 2 - left */ #define EXTIN_LINE2_R 0x0d /* LiveDrive - Line/Mic 2 - right */ /* Outputs */ #define EXTOUT_AC97_L 0x00 /* AC'97 playback channel - left */ #define EXTOUT_AC97_R 0x01 /* AC'97 playback channel - right */ #define EXTOUT_TOSLINK_L 0x02 /* LiveDrive - TOSLink Optical - left */ #define EXTOUT_TOSLINK_R 0x03 /* LiveDrive - TOSLink Optical - right */ #define EXTOUT_AC97_CENTER 0x04 /* SB Live 5.1 - center */ #define EXTOUT_AC97_LFE 0x05 /* SB Live 5.1 - LFE */ #define EXTOUT_HEADPHONE_L 0x06 /* LiveDrive - Headphone - left */ #define EXTOUT_HEADPHONE_R 0x07 /* LiveDrive - Headphone - right */ #define EXTOUT_REAR_L 0x08 /* Rear channel - left */ #define EXTOUT_REAR_R 0x09 /* Rear channel - right */ #define EXTOUT_ADC_CAP_L 0x0a /* ADC Capture buffer - left */ #define EXTOUT_ADC_CAP_R 0x0b /* ADC Capture buffer - right */ #define EXTOUT_MIC_CAP 0x0c /* MIC Capture buffer */ #define EXTOUT_AC97_REAR_L 0x0d /* SB Live 5.1 (c) 2003 - Rear Left */ #define EXTOUT_AC97_REAR_R 0x0e /* SB Live 5.1 (c) 2003 - Rear Right */ #define EXTOUT_ACENTER 0x11 /* Analog Center */ #define EXTOUT_ALFE 0x12 /* Analog LFE */ /* Audigy Inputs */ #define A_EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ #define A_EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ #define A_EXTIN_SPDIF_CD_L 0x02 /* digital CD left */ #define A_EXTIN_SPDIF_CD_R 0x03 /* digital CD left */ #define A_EXTIN_OPT_SPDIF_L 0x04 /* audigy drive Optical SPDIF - left */ #define A_EXTIN_OPT_SPDIF_R 0x05 /* right */ #define A_EXTIN_LINE2_L 0x08 /* audigy drive line2/mic2 - left */ #define A_EXTIN_LINE2_R 0x09 /* right */ #define A_EXTIN_ADC_L 0x0a /* Philips ADC - left */ #define A_EXTIN_ADC_R 0x0b /* right */ #define A_EXTIN_AUX2_L 0x0c /* audigy drive aux2 - left */ #define A_EXTIN_AUX2_R 0x0d /* - right */ /* Audigiy Outputs */ #define A_EXTOUT_FRONT_L 0x00 /* digital front left */ #define A_EXTOUT_FRONT_R 0x01 /* right */ #define A_EXTOUT_CENTER 0x02 /* digital front center */ #define A_EXTOUT_LFE 0x03 /* digital front lfe */ #define A_EXTOUT_HEADPHONE_L 0x04 /* headphone audigy drive left */ #define A_EXTOUT_HEADPHONE_R 0x05 /* right */ #define A_EXTOUT_REAR_L 0x06 /* digital rear left */ #define A_EXTOUT_REAR_R 0x07 /* right */ #define A_EXTOUT_AFRONT_L 0x08 /* analog front left */ #define A_EXTOUT_AFRONT_R 0x09 /* right */ #define A_EXTOUT_ACENTER 0x0a /* analog center */ #define A_EXTOUT_ALFE 0x0b /* analog LFE */ #define A_EXTOUT_ASIDE_L 0x0c /* analog side left - Audigy 2 ZS */ #define A_EXTOUT_ASIDE_R 0x0d /* right - Audigy 2 ZS */ #define A_EXTOUT_AREAR_L 0x0e /* analog rear left */ #define A_EXTOUT_AREAR_R 0x0f /* right */ #define A_EXTOUT_AC97_L 0x10 /* AC97 left (front) */ #define A_EXTOUT_AC97_R 0x11 /* right */ #define A_EXTOUT_ADC_CAP_L 0x16 /* ADC capture buffer left */ #define A_EXTOUT_ADC_CAP_R 0x17 /* right */ #define A_EXTOUT_MIC_CAP 0x18 /* Mic capture buffer */ /* Definitions for debug register. Note that these are for emu10k1 ONLY. */ #define EMU10K1_DBG_ZC 0x80000000 /* zero tram counter */ #define EMU10K1_DBG_SATURATION_OCCURED 0x02000000 /* saturation control */ #define EMU10K1_DBG_SATURATION_ADDR 0x01ff0000 /* saturation address */ #define EMU10K1_DBG_SINGLE_STEP 0x00008000 /* single step mode */ #define EMU10K1_DBG_STEP 0x00004000 /* start single step */ #define EMU10K1_DBG_CONDITION_CODE 0x00003e00 /* condition code */ #define EMU10K1_DBG_SINGLE_STEP_ADDR 0x000001ff /* single step address */ /* Definitions for emu10k2 debug register. */ #define A_DBG_ZC 0x40000000 /* zero tram counter */ #define A_DBG_SATURATION_OCCURED 0x20000000 #define A_DBG_SATURATION_ADDR 0x0ffc0000 #define A_DBG_SINGLE_STEP 0x00020000 /* Set to zero to start dsp */ #define A_DBG_STEP 0x00010000 #define A_DBG_CONDITION_CODE 0x0000f800 #define A_DBG_STEP_ADDR 0x000003ff struct snd_emu10k1_fx8010_info { unsigned int internal_tram_size; /* in samples */ unsigned int external_tram_size; /* in samples */ char fxbus_names[16][32]; /* names of FXBUSes */ char extin_names[16][32]; /* names of external inputs */ char extout_names[32][32]; /* names of external outputs */ unsigned int gpr_controls; /* count of GPR controls */ }; #define EMU10K1_GPR_TRANSLATION_NONE 0 #define EMU10K1_GPR_TRANSLATION_TABLE100 1 #define EMU10K1_GPR_TRANSLATION_BASS 2 #define EMU10K1_GPR_TRANSLATION_TREBLE 3 #define EMU10K1_GPR_TRANSLATION_ONOFF 4 enum emu10k1_ctl_elem_iface { EMU10K1_CTL_ELEM_IFACE_MIXER = 2, /* virtual mixer device */ EMU10K1_CTL_ELEM_IFACE_PCM = 3, /* PCM device */ }; struct emu10k1_ctl_elem_id { unsigned int pad; /* don't use */ int iface; /* interface identifier */ unsigned int device; /* device/client number */ unsigned int subdevice; /* subdevice (substream) number */ unsigned char name[44]; /* ASCII name of item */ unsigned int index; /* index of item */ }; struct snd_emu10k1_fx8010_control_gpr { struct emu10k1_ctl_elem_id id; /* full control ID definition */ unsigned int vcount; /* visible count */ unsigned int count; /* count of GPR (1..16) */ unsigned short gpr[32]; /* GPR number(s) */ unsigned int value[32]; /* initial values */ unsigned int min; /* minimum range */ unsigned int max; /* maximum range */ unsigned int translation; /* translation type (EMU10K1_GPR_TRANSLATION*) */ const unsigned int *tlv; }; /* old ABI without TLV support */ struct snd_emu10k1_fx8010_control_old_gpr { struct emu10k1_ctl_elem_id id; unsigned int vcount; unsigned int count; unsigned short gpr[32]; unsigned int value[32]; unsigned int min; unsigned int max; unsigned int translation; }; struct snd_emu10k1_fx8010_code { char name[128]; __EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */ __u32 *gpr_map; /* initializers */ unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */ struct snd_emu10k1_fx8010_control_gpr *gpr_add_controls; /* GPR controls to add/replace */ unsigned int gpr_del_control_count; /* count of GPR controls to remove */ struct emu10k1_ctl_elem_id *gpr_del_controls; /* IDs of GPR controls to remove */ unsigned int gpr_list_control_count; /* count of GPR controls to list */ unsigned int gpr_list_control_total; /* total count of GPR controls */ struct snd_emu10k1_fx8010_control_gpr *gpr_list_controls; /* listed GPR controls */ __EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */ __u32 *tram_data_map; /* data initializers */ __u32 *tram_addr_map; /* map initializers */ __EMU10K1_DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */ __u32 *code; /* one instruction - 64 bits */ }; struct snd_emu10k1_fx8010_tram { unsigned int address; /* 31.bit == 1 -> external TRAM */ unsigned int size; /* size in samples (4 bytes) */ unsigned int *samples; /* pointer to samples (20-bit) */ /* NULL->clear memory */ }; struct snd_emu10k1_fx8010_pcm_rec { unsigned int substream; /* substream number */ unsigned int res1; /* reserved */ unsigned int channels; /* 16-bit channels count, zero = remove this substream */ unsigned int tram_start; /* ring buffer position in TRAM (in samples) */ unsigned int buffer_size; /* count of buffered samples */ unsigned short gpr_size; /* GPR containing size of ringbuffer in samples (host) */ unsigned short gpr_ptr; /* GPR containing current pointer in the ring buffer (host = reset, FX8010) */ unsigned short gpr_count; /* GPR containing count of samples between two interrupts (host) */ unsigned short gpr_tmpcount; /* GPR containing current count of samples to interrupt (host = set, FX8010) */ unsigned short gpr_trigger; /* GPR containing trigger (activate) information (host) */ unsigned short gpr_running; /* GPR containing info if PCM is running (FX8010) */ unsigned char pad; /* reserved */ unsigned char etram[32]; /* external TRAM address & data (one per channel) */ unsigned int res2; /* reserved */ }; #define SNDRV_EMU10K1_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) #define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info) #define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code) #define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code) #define SNDRV_EMU10K1_IOCTL_TRAM_SETUP _IOW ('H', 0x20, int) #define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram) #define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram) #define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec) #define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec) #define SNDRV_EMU10K1_IOCTL_PVERSION _IOR ('H', 0x40, int) #define SNDRV_EMU10K1_IOCTL_STOP _IO ('H', 0x80) #define SNDRV_EMU10K1_IOCTL_CONTINUE _IO ('H', 0x81) #define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82) #define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) #define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) #endif /* __SOUND_EMU10K1_H */ sound/sof/tokens.h000064400000015231152640040150010136 0ustar00/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ /* * This file is provided under a dual BSD/GPLv2 license. When using or * redistributing this file, you may do so under either license. * * Copyright(c) 2018 Intel Corporation. All rights reserved. * Author: Liam Girdwood * Keyon Jie */ /* * Topology IDs and tokens. * * ** MUST BE ALIGNED WITH TOPOLOGY CONFIGURATION TOKEN VALUES ** */ #ifndef __INCLUDE_UAPI_SOF_TOPOLOGY_H__ #define __INCLUDE_UAPI_SOF_TOPOLOGY_H__ /* * Kcontrol IDs */ #define SOF_TPLG_KCTL_VOL_ID 256 #define SOF_TPLG_KCTL_ENUM_ID 257 #define SOF_TPLG_KCTL_BYTES_ID 258 #define SOF_TPLG_KCTL_SWITCH_ID 259 #define SOF_TPLG_KCTL_BYTES_VOLATILE_RO 260 #define SOF_TPLG_KCTL_BYTES_VOLATILE_RW 261 #define SOF_TPLG_KCTL_BYTES_WO_ID 262 /* * Tokens - must match values in topology configurations */ /* buffers */ #define SOF_TKN_BUF_SIZE 100 #define SOF_TKN_BUF_CAPS 101 /* DAI */ /* Token retired with ABI 3.2, do not use for new capabilities * #define SOF_TKN_DAI_DMAC_CONFIG 153 */ #define SOF_TKN_DAI_TYPE 154 #define SOF_TKN_DAI_INDEX 155 #define SOF_TKN_DAI_DIRECTION 156 /* scheduling */ #define SOF_TKN_SCHED_PERIOD 200 #define SOF_TKN_SCHED_PRIORITY 201 #define SOF_TKN_SCHED_MIPS 202 #define SOF_TKN_SCHED_CORE 203 #define SOF_TKN_SCHED_FRAMES 204 #define SOF_TKN_SCHED_TIME_DOMAIN 205 #define SOF_TKN_SCHED_DYNAMIC_PIPELINE 206 #define SOF_TKN_SCHED_LP_MODE 207 #define SOF_TKN_SCHED_MEM_USAGE 208 #define SOF_TKN_SCHED_USE_CHAIN_DMA 209 /* volume */ #define SOF_TKN_VOLUME_RAMP_STEP_TYPE 250 #define SOF_TKN_VOLUME_RAMP_STEP_MS 251 #define SOF_TKN_GAIN_RAMP_TYPE 260 #define SOF_TKN_GAIN_RAMP_DURATION 261 #define SOF_TKN_GAIN_VAL 262 /* SRC */ #define SOF_TKN_SRC_RATE_IN 300 #define SOF_TKN_SRC_RATE_OUT 301 /* ASRC */ #define SOF_TKN_ASRC_RATE_IN 320 #define SOF_TKN_ASRC_RATE_OUT 321 #define SOF_TKN_ASRC_ASYNCHRONOUS_MODE 322 #define SOF_TKN_ASRC_OPERATION_MODE 323 /* PCM */ #define SOF_TKN_PCM_DMAC_CONFIG 353 /* Generic components */ #define SOF_TKN_COMP_PERIOD_SINK_COUNT 400 #define SOF_TKN_COMP_PERIOD_SOURCE_COUNT 401 #define SOF_TKN_COMP_FORMAT 402 /* Token retired with ABI 3.2, do not use for new capabilities * #define SOF_TKN_COMP_PRELOAD_COUNT 403 */ #define SOF_TKN_COMP_CORE_ID 404 #define SOF_TKN_COMP_UUID 405 #define SOF_TKN_COMP_CPC 406 #define SOF_TKN_COMP_IS_PAGES 409 #define SOF_TKN_COMP_NUM_AUDIO_FORMATS 410 #define SOF_TKN_COMP_NUM_INPUT_PINS 411 #define SOF_TKN_COMP_NUM_OUTPUT_PINS 412 /* * The token for input/output pin binding, it specifies the widget * name that the input/output pin is connected from/to. */ #define SOF_TKN_COMP_INPUT_PIN_BINDING_WNAME 413 #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 /* * The token value is copied to the dapm_widget's * no_wname_in_kcontrol_name. */ #define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 /* SSP */ #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 #define SOF_TKN_INTEL_SSP_MCLK_ID 501 #define SOF_TKN_INTEL_SSP_SAMPLE_BITS 502 #define SOF_TKN_INTEL_SSP_FRAME_PULSE_WIDTH 503 #define SOF_TKN_INTEL_SSP_QUIRKS 504 #define SOF_TKN_INTEL_SSP_TDM_PADDING_PER_SLOT 505 #define SOF_TKN_INTEL_SSP_BCLK_DELAY 506 /* DMIC */ #define SOF_TKN_INTEL_DMIC_DRIVER_VERSION 600 #define SOF_TKN_INTEL_DMIC_CLK_MIN 601 #define SOF_TKN_INTEL_DMIC_CLK_MAX 602 #define SOF_TKN_INTEL_DMIC_DUTY_MIN 603 #define SOF_TKN_INTEL_DMIC_DUTY_MAX 604 #define SOF_TKN_INTEL_DMIC_NUM_PDM_ACTIVE 605 #define SOF_TKN_INTEL_DMIC_SAMPLE_RATE 608 #define SOF_TKN_INTEL_DMIC_FIFO_WORD_LENGTH 609 #define SOF_TKN_INTEL_DMIC_UNMUTE_RAMP_TIME_MS 610 /* DMIC PDM */ #define SOF_TKN_INTEL_DMIC_PDM_CTRL_ID 700 #define SOF_TKN_INTEL_DMIC_PDM_MIC_A_Enable 701 #define SOF_TKN_INTEL_DMIC_PDM_MIC_B_Enable 702 #define SOF_TKN_INTEL_DMIC_PDM_POLARITY_A 703 #define SOF_TKN_INTEL_DMIC_PDM_POLARITY_B 704 #define SOF_TKN_INTEL_DMIC_PDM_CLK_EDGE 705 #define SOF_TKN_INTEL_DMIC_PDM_SKEW 706 /* Tone */ #define SOF_TKN_TONE_SAMPLE_RATE 800 /* Processing Components */ #define SOF_TKN_PROCESS_TYPE 900 /* for backward compatibility */ #define SOF_TKN_EFFECT_TYPE SOF_TKN_PROCESS_TYPE /* SAI */ #define SOF_TKN_IMX_SAI_MCLK_ID 1000 /* ESAI */ #define SOF_TKN_IMX_ESAI_MCLK_ID 1100 /* Stream */ #define SOF_TKN_STREAM_PLAYBACK_COMPATIBLE_D0I3 1200 #define SOF_TKN_STREAM_CAPTURE_COMPATIBLE_D0I3 1201 /* Led control for mute switches */ #define SOF_TKN_MUTE_LED_USE 1300 #define SOF_TKN_MUTE_LED_DIRECTION 1301 /* ALH */ #define SOF_TKN_INTEL_ALH_RATE 1400 #define SOF_TKN_INTEL_ALH_CH 1401 /* HDA */ #define SOF_TKN_INTEL_HDA_RATE 1500 #define SOF_TKN_INTEL_HDA_CH 1501 /* AFE */ #define SOF_TKN_MEDIATEK_AFE_RATE 1600 #define SOF_TKN_MEDIATEK_AFE_CH 1601 #define SOF_TKN_MEDIATEK_AFE_FORMAT 1602 /* MIXER */ #define SOF_TKN_MIXER_TYPE 1700 /* ACPDMIC */ #define SOF_TKN_AMD_ACPDMIC_RATE 1800 #define SOF_TKN_AMD_ACPDMIC_CH 1801 /* CAVS AUDIO FORMAT */ #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_RATE 1900 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_BIT_DEPTH 1901 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_VALID_BIT_DEPTH 1902 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_CHANNELS 1903 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_MAP 1904 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_CH_CFG 1905 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_INTERLEAVING_STYLE 1906 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_FMT_CFG 1907 #define SOF_TKN_CAVS_AUDIO_FORMAT_IN_SAMPLE_TYPE 1908 #define SOF_TKN_CAVS_AUDIO_FORMAT_INPUT_PIN_INDEX 1909 /* intentional token numbering discontinuity, reserved for future use */ #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_RATE 1930 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_BIT_DEPTH 1931 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_VALID_BIT_DEPTH 1932 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CHANNELS 1933 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_MAP 1934 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_CH_CFG 1935 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_INTERLEAVING_STYLE 1936 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_FMT_CFG 1937 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUT_SAMPLE_TYPE 1938 #define SOF_TKN_CAVS_AUDIO_FORMAT_OUTPUT_PIN_INDEX 1939 /* intentional token numbering discontinuity, reserved for future use */ #define SOF_TKN_CAVS_AUDIO_FORMAT_IBS 1970 #define SOF_TKN_CAVS_AUDIO_FORMAT_OBS 1971 #define SOF_TKN_CAVS_AUDIO_FORMAT_DMA_BUFFER_SIZE 1972 /* COPIER */ #define SOF_TKN_INTEL_COPIER_NODE_TYPE 1980 #define SOF_TKN_INTEL_COPIER_DEEP_BUFFER_DMA_MS 1981 /* ACP I2S */ #define SOF_TKN_AMD_ACPI2S_RATE 1700 #define SOF_TKN_AMD_ACPI2S_CH 1701 #define SOF_TKN_AMD_ACPI2S_TDM_MODE 1702 #endif sound/sof/fw.h000064400000004333152640040150007250 0ustar00/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ /* * This file is provided under a dual BSD/GPLv2 license. When using or * redistributing this file, you may do so under either license. * * Copyright(c) 2018 Intel Corporation. All rights reserved. */ /* * Firmware file format . */ #ifndef __INCLUDE_UAPI_SOF_FW_H__ #define __INCLUDE_UAPI_SOF_FW_H__ #include #define SND_SOF_FW_SIG_SIZE 4 #define SND_SOF_FW_ABI 1 #define SND_SOF_FW_SIG "Reef" /* * Firmware module is made up of 1 . N blocks of different types. The * Block header is used to determine where and how block is to be copied in the * DSP/host memory space. */ enum snd_sof_fw_blk_type { SOF_FW_BLK_TYPE_INVALID = -1, SOF_FW_BLK_TYPE_START = 0, SOF_FW_BLK_TYPE_RSRVD0 = SOF_FW_BLK_TYPE_START, SOF_FW_BLK_TYPE_IRAM = 1, /* local instruction RAM */ SOF_FW_BLK_TYPE_DRAM = 2, /* local data RAM */ SOF_FW_BLK_TYPE_SRAM = 3, /* system RAM */ SOF_FW_BLK_TYPE_ROM = 4, SOF_FW_BLK_TYPE_IMR = 5, SOF_FW_BLK_TYPE_RSRVD6 = 6, SOF_FW_BLK_TYPE_RSRVD7 = 7, SOF_FW_BLK_TYPE_RSRVD8 = 8, SOF_FW_BLK_TYPE_RSRVD9 = 9, SOF_FW_BLK_TYPE_RSRVD10 = 10, SOF_FW_BLK_TYPE_RSRVD11 = 11, SOF_FW_BLK_TYPE_RSRVD12 = 12, SOF_FW_BLK_TYPE_RSRVD13 = 13, SOF_FW_BLK_TYPE_RSRVD14 = 14, /* use SOF_FW_BLK_TYPE_RSVRDX for new block types */ SOF_FW_BLK_TYPE_NUM }; struct snd_sof_blk_hdr { enum snd_sof_fw_blk_type type; __u32 size; /* bytes minus this header */ __u32 offset; /* offset from base */ } __attribute__((packed)); /* * Firmware file is made up of 1 .. N different modules types. The module * type is used to determine how to load and parse the module. */ enum snd_sof_fw_mod_type { SOF_FW_BASE = 0, /* base firmware image */ SOF_FW_MODULE = 1, /* firmware module */ }; struct snd_sof_mod_hdr { enum snd_sof_fw_mod_type type; __u32 size; /* bytes minus this header */ __u32 num_blocks; /* number of blocks */ } __attribute__((packed)); /* * Firmware file header. */ struct snd_sof_fw_header { unsigned char sig[SND_SOF_FW_SIG_SIZE]; /* "Reef" */ __u32 file_size; /* size of file minus this header */ __u32 num_modules; /* number of modules */ __u32 abi; /* version of header format */ } __attribute__((packed)); #endif sound/sof/abi.h000064400000004134152640040150007366 0ustar00/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ /* * This file is provided under a dual BSD/GPLv2 license. When using or * redistributing this file, you may do so under either license. * * Copyright(c) 2018 Intel Corporation. All rights reserved. */ /** * SOF ABI versioning is based on Semantic Versioning where we have a given * MAJOR.MINOR.PATCH version number. See https://semver.org/ * * Rules for incrementing or changing version :- * * 1) Increment MAJOR version if you make incompatible API changes. MINOR and * PATCH should be reset to 0. * * 2) Increment MINOR version if you add backwards compatible features or * changes. PATCH should be reset to 0. * * 3) Increment PATCH version if you add backwards compatible bug fixes. */ #ifndef __INCLUDE_UAPI_SOUND_SOF_ABI_H__ #define __INCLUDE_UAPI_SOUND_SOF_ABI_H__ #include /* SOF ABI version major, minor and patch numbers */ #define SOF_ABI_MAJOR 3 #define SOF_ABI_MINOR 23 #define SOF_ABI_PATCH 0 /* SOF ABI version number. Format within 32bit word is MMmmmppp */ #define SOF_ABI_MAJOR_SHIFT 24 #define SOF_ABI_MAJOR_MASK 0xff #define SOF_ABI_MINOR_SHIFT 12 #define SOF_ABI_MINOR_MASK 0xfff #define SOF_ABI_PATCH_SHIFT 0 #define SOF_ABI_PATCH_MASK 0xfff #define SOF_ABI_VER(major, minor, patch) \ (((major) << SOF_ABI_MAJOR_SHIFT) | \ ((minor) << SOF_ABI_MINOR_SHIFT) | \ ((patch) << SOF_ABI_PATCH_SHIFT)) #define SOF_ABI_VERSION_MAJOR(version) \ (((version) >> SOF_ABI_MAJOR_SHIFT) & SOF_ABI_MAJOR_MASK) #define SOF_ABI_VERSION_MINOR(version) \ (((version) >> SOF_ABI_MINOR_SHIFT) & SOF_ABI_MINOR_MASK) #define SOF_ABI_VERSION_PATCH(version) \ (((version) >> SOF_ABI_PATCH_SHIFT) & SOF_ABI_PATCH_MASK) #define SOF_ABI_VERSION_INCOMPATIBLE(sof_ver, client_ver) \ (SOF_ABI_VERSION_MAJOR((sof_ver)) != \ SOF_ABI_VERSION_MAJOR((client_ver)) \ ) #define SOF_ABI_VERSION SOF_ABI_VER(SOF_ABI_MAJOR, SOF_ABI_MINOR, SOF_ABI_PATCH) /* SOF ABI magic number "SOF\0". */ #define SOF_ABI_MAGIC 0x00464F53 /* SOF IPC4 ABI magic number "SOF4". */ #define SOF_IPC4_ABI_MAGIC 0x34464F53 #endif sound/sof/header.h000064400000003571152640040150010067 0ustar00/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ /* * This file is provided under a dual BSD/GPLv2 license. When using or * redistributing this file, you may do so under either license. * * Copyright(c) 2018 Intel Corporation. All rights reserved. */ #ifndef __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__ #define __INCLUDE_UAPI_SOUND_SOF_USER_HEADER_H__ #include /** * struct sof_abi_hdr - Header for all non IPC ABI data. * @magic: Magic number for validation * for IPC3 data: 0x00464F53 ('S', 'O', 'F', '\0') * for IPC4 data: 0x34464F53 ('S', 'O', 'F', '4') * @type: module specific parameter * for IPC3: Component specific type * for IPC4: parameter ID (param_id) of the data * @size: The size in bytes of the data, excluding this struct * @abi: SOF ABI version. The version is valid in scope of the 'magic', IPC3 and * IPC4 ABI version numbers have no relationship. * @reserved: Reserved for future use * @data: Component data - opaque to core * * Identifies data type, size and ABI. * Used by any bespoke component data structures or binary blobs. */ struct sof_abi_hdr { __u32 magic; __u32 type; __u32 size; __u32 abi; __u32 reserved[4]; __u32 data[0]; } __attribute__((packed)); #define SOF_MANIFEST_DATA_TYPE_NHLT 1 /** * struct sof_manifest_tlv - SOF manifest TLV data * @type: type of data * @size: data size (not including the size of this struct) * @data: payload data */ struct sof_manifest_tlv { __le32 type; __le32 size; __u8 data[]; }; /** * struct sof_manifest - SOF topology manifest * @abi_major: Major ABI version * @abi_minor: Minor ABI version * @abi_patch: ABI patch * @count: count of tlv items * @items: consecutive variable size tlv items */ struct sof_manifest { __le16 abi_major; __le16 abi_minor; __le16 abi_patch; __le16 count; struct sof_manifest_tlv items[]; }; #endif sound/intel/avs/tokens.h000064400000010605152640040150011253 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * Copyright(c) 2021 Intel Corporation. All rights reserved. * * Authors: Cezary Rojewski * Amadeusz Slawinski */ #ifndef __UAPI_SOUND_INTEL_AVS_TOKENS_H #define __UAPI_SOUND_INTEL_AVS_TOKENS_H enum avs_tplg_token { /* struct avs_tplg */ AVS_TKN_MANIFEST_NAME_STRING = 1, AVS_TKN_MANIFEST_VERSION_U32 = 2, AVS_TKN_MANIFEST_NUM_LIBRARIES_U32 = 3, AVS_TKN_MANIFEST_NUM_AFMTS_U32 = 4, AVS_TKN_MANIFEST_NUM_MODCFGS_BASE_U32 = 5, AVS_TKN_MANIFEST_NUM_MODCFGS_EXT_U32 = 6, AVS_TKN_MANIFEST_NUM_PPLCFGS_U32 = 7, AVS_TKN_MANIFEST_NUM_BINDINGS_U32 = 8, /* struct avs_tplg_library */ AVS_TKN_LIBRARY_ID_U32 = 101, AVS_TKN_LIBRARY_NAME_STRING = 102, /* struct avs_audio_format */ AVS_TKN_AFMT_ID_U32 = 201, AVS_TKN_AFMT_SAMPLE_RATE_U32 = 202, AVS_TKN_AFMT_BIT_DEPTH_U32 = 203, AVS_TKN_AFMT_CHANNEL_MAP_U32 = 204, AVS_TKN_AFMT_CHANNEL_CFG_U32 = 205, AVS_TKN_AFMT_INTERLEAVING_U32 = 206, AVS_TKN_AFMT_NUM_CHANNELS_U32 = 207, AVS_TKN_AFMT_VALID_BIT_DEPTH_U32 = 208, AVS_TKN_AFMT_SAMPLE_TYPE_U32 = 209, /* struct avs_tplg_modcfg_base */ AVS_TKN_MODCFG_BASE_ID_U32 = 301, AVS_TKN_MODCFG_BASE_CPC_U32 = 302, AVS_TKN_MODCFG_BASE_IBS_U32 = 303, AVS_TKN_MODCFG_BASE_OBS_U32 = 304, AVS_TKN_MODCFG_BASE_PAGES_U32 = 305, /* struct avs_tplg_modcfg_ext */ AVS_TKN_MODCFG_EXT_ID_U32 = 401, AVS_TKN_MODCFG_EXT_TYPE_UUID = 402, AVS_TKN_MODCFG_CPR_OUT_AFMT_ID_U32 = 403, AVS_TKN_MODCFG_CPR_FEATURE_MASK_U32 = 404, AVS_TKN_MODCFG_CPR_DMA_TYPE_U32 = 405, AVS_TKN_MODCFG_CPR_DMABUFF_SIZE_U32 = 406, AVS_TKN_MODCFG_CPR_VINDEX_U8 = 407, AVS_TKN_MODCFG_CPR_BLOB_FMT_ID_U32 = 408, AVS_TKN_MODCFG_MICSEL_OUT_AFMT_ID_U32 = 409, AVS_TKN_MODCFG_INTELWOV_CPC_LP_MODE_U32 = 410, AVS_TKN_MODCFG_SRC_OUT_FREQ_U32 = 411, AVS_TKN_MODCFG_MUX_REF_AFMT_ID_U32 = 412, AVS_TKN_MODCFG_MUX_OUT_AFMT_ID_U32 = 413, AVS_TKN_MODCFG_AEC_REF_AFMT_ID_U32 = 414, AVS_TKN_MODCFG_AEC_OUT_AFMT_ID_U32 = 415, AVS_TKN_MODCFG_AEC_CPC_LP_MODE_U32 = 416, AVS_TKN_MODCFG_ASRC_OUT_FREQ_U32 = 417, AVS_TKN_MODCFG_ASRC_MODE_U8 = 418, AVS_TKN_MODCFG_ASRC_DISABLE_JITTER_U8 = 419, AVS_TKN_MODCFG_UPDOWN_MIX_OUT_CHAN_CFG_U32 = 420, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_SELECT_U32 = 421, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_0_S32 = 422, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_1_S32 = 423, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_2_S32 = 424, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_3_S32 = 425, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_4_S32 = 426, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_5_S32 = 427, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_6_S32 = 428, AVS_TKN_MODCFG_UPDOWN_MIX_COEFF_7_S32 = 429, AVS_TKN_MODCFG_UPDOWN_MIX_CHAN_MAP_U32 = 430, AVS_TKN_MODCFG_EXT_NUM_INPUT_PINS_U16 = 431, AVS_TKN_MODCFG_EXT_NUM_OUTPUT_PINS_U16 = 432, /* struct avs_tplg_pplcfg */ AVS_TKN_PPLCFG_ID_U32 = 1401, AVS_TKN_PPLCFG_REQ_SIZE_U16 = 1402, AVS_TKN_PPLCFG_PRIORITY_U8 = 1403, AVS_TKN_PPLCFG_LOW_POWER_BOOL = 1404, AVS_TKN_PPLCFG_ATTRIBUTES_U16 = 1405, AVS_TKN_PPLCFG_TRIGGER_U32 = 1406, /* struct avs_tplg_binding */ AVS_TKN_BINDING_ID_U32 = 1501, AVS_TKN_BINDING_TARGET_TPLG_NAME_STRING = 1502, AVS_TKN_BINDING_TARGET_PATH_TMPL_ID_U32 = 1503, AVS_TKN_BINDING_TARGET_PPL_ID_U32 = 1504, AVS_TKN_BINDING_TARGET_MOD_ID_U32 = 1505, AVS_TKN_BINDING_TARGET_MOD_PIN_U8 = 1506, AVS_TKN_BINDING_MOD_ID_U32 = 1507, AVS_TKN_BINDING_MOD_PIN_U8 = 1508, AVS_TKN_BINDING_IS_SINK_U8 = 1509, /* struct avs_tplg_pipeline */ AVS_TKN_PPL_ID_U32 = 1601, AVS_TKN_PPL_PPLCFG_ID_U32 = 1602, AVS_TKN_PPL_NUM_BINDING_IDS_U32 = 1603, AVS_TKN_PPL_BINDING_ID_U32 = 1604, /* struct avs_tplg_module */ AVS_TKN_MOD_ID_U32 = 1701, AVS_TKN_MOD_MODCFG_BASE_ID_U32 = 1702, AVS_TKN_MOD_IN_AFMT_ID_U32 = 1703, AVS_TKN_MOD_CORE_ID_U8 = 1704, AVS_TKN_MOD_PROC_DOMAIN_U8 = 1705, AVS_TKN_MOD_MODCFG_EXT_ID_U32 = 1706, AVS_TKN_MOD_KCONTROL_ID_U32 = 1707, /* struct avs_tplg_path_template */ AVS_TKN_PATH_TMPL_ID_U32 = 1801, /* struct avs_tplg_path */ AVS_TKN_PATH_ID_U32 = 1901, AVS_TKN_PATH_FE_FMT_ID_U32 = 1902, AVS_TKN_PATH_BE_FMT_ID_U32 = 1903, /* struct avs_tplg_pin_format */ AVS_TKN_PIN_FMT_INDEX_U32 = 2201, AVS_TKN_PIN_FMT_IOBS_U32 = 2202, AVS_TKN_PIN_FMT_AFMT_ID_U32 = 2203, /* struct avs_tplg_kcontrol */ AVS_TKN_KCONTROL_ID_U32 = 2301, }; #endif sound/asound.h000064400000144024152640040150007340 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * Advanced Linux Sound Architecture - ALSA - Driver * Copyright (c) 1994-2003 by Jaroslav Kysela , * Abramo Bagnara */ #ifndef __SOUND_ASOUND_H #define __SOUND_ASOUND_H #if defined(__KERNEL__) || defined(__linux__) #include #include #else #include #include #endif #include #include /* * protocol version */ #define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor)) #define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff) #define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff) #define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff) #define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \ (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \ (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \ SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion))) /**************************************************************************** * * * Digital audio interface * * * ****************************************************************************/ #define AES_IEC958_STATUS_SIZE 24 struct snd_aes_iec958 { unsigned char status[AES_IEC958_STATUS_SIZE]; /* AES/IEC958 channel status bits */ unsigned char subcode[147]; /* AES/IEC958 subcode bits */ unsigned char pad; /* nothing */ unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */ }; /**************************************************************************** * * * CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort * * * ****************************************************************************/ struct snd_cea_861_aud_if { unsigned char db1_ct_cc; /* coding type and channel count */ unsigned char db2_sf_ss; /* sample frequency and size */ unsigned char db3; /* not used, all zeros */ unsigned char db4_ca; /* channel allocation code */ unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */ }; /**************************************************************************** * * * Section for driver hardware dependent interface - /dev/snd/hw? * * * ****************************************************************************/ #define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) enum { SNDRV_HWDEP_IFACE_OPL2 = 0, SNDRV_HWDEP_IFACE_OPL3, SNDRV_HWDEP_IFACE_OPL4, SNDRV_HWDEP_IFACE_SB16CSP, /* Creative Signal Processor */ SNDRV_HWDEP_IFACE_EMU10K1, /* FX8010 processor in EMU10K1 chip */ SNDRV_HWDEP_IFACE_YSS225, /* Yamaha FX processor */ SNDRV_HWDEP_IFACE_ICS2115, /* Wavetable synth */ SNDRV_HWDEP_IFACE_SSCAPE, /* Ensoniq SoundScape ISA card (MC68EC000) */ SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */ SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */ SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */ SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */ SNDRV_HWDEP_IFACE_BLUETOOTH, /* Bluetooth audio */ SNDRV_HWDEP_IFACE_USX2Y_PCM, /* Tascam US122, US224 & US428 rawusb pcm */ SNDRV_HWDEP_IFACE_PCXHR, /* Digigram PCXHR */ SNDRV_HWDEP_IFACE_SB_RC, /* SB Extigy/Audigy2NX remote control */ SNDRV_HWDEP_IFACE_HDA, /* HD-audio */ SNDRV_HWDEP_IFACE_USB_STREAM, /* direct access to usb stream */ SNDRV_HWDEP_IFACE_FW_DICE, /* TC DICE FireWire device */ SNDRV_HWDEP_IFACE_FW_FIREWORKS, /* Echo Audio Fireworks based device */ SNDRV_HWDEP_IFACE_FW_BEBOB, /* BridgeCo BeBoB based device */ SNDRV_HWDEP_IFACE_FW_OXFW, /* Oxford OXFW970/971 based device */ SNDRV_HWDEP_IFACE_FW_DIGI00X, /* Digidesign Digi 002/003 family */ SNDRV_HWDEP_IFACE_FW_TASCAM, /* TASCAM FireWire series */ SNDRV_HWDEP_IFACE_LINE6, /* Line6 USB processors */ SNDRV_HWDEP_IFACE_FW_MOTU, /* MOTU FireWire series */ SNDRV_HWDEP_IFACE_FW_FIREFACE, /* RME Fireface series */ /* Don't forget to change the following: */ SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE }; struct snd_hwdep_info { unsigned int device; /* WR: device number */ int card; /* R: card number */ unsigned char id[64]; /* ID (user selectable) */ unsigned char name[80]; /* hwdep name */ int iface; /* hwdep interface */ unsigned char reserved[64]; /* reserved for future */ }; /* generic DSP loader */ struct snd_hwdep_dsp_status { unsigned int version; /* R: driver-specific version */ unsigned char id[32]; /* R: driver-specific ID string */ unsigned int num_dsps; /* R: number of DSP images to transfer */ unsigned int dsp_loaded; /* R: bit flags indicating the loaded DSPs */ unsigned int chip_ready; /* R: 1 = initialization finished */ unsigned char reserved[16]; /* reserved for future use */ }; struct snd_hwdep_dsp_image { unsigned int index; /* W: DSP index */ unsigned char name[64]; /* W: ID (e.g. file name) */ unsigned char *image; /* W: binary image */ size_t length; /* W: size of image in bytes */ unsigned long driver_data; /* W: driver-specific data */ }; #define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int) #define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct snd_hwdep_info) #define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct snd_hwdep_dsp_status) #define SNDRV_HWDEP_IOCTL_DSP_LOAD _IOW('H', 0x03, struct snd_hwdep_dsp_image) /***************************************************************************** * * * Digital Audio (PCM) interface - /dev/snd/pcm?? * * * *****************************************************************************/ #define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 15) typedef unsigned long snd_pcm_uframes_t; typedef signed long snd_pcm_sframes_t; enum { SNDRV_PCM_CLASS_GENERIC = 0, /* standard mono or stereo device */ SNDRV_PCM_CLASS_MULTI, /* multichannel device */ SNDRV_PCM_CLASS_MODEM, /* software modem class */ SNDRV_PCM_CLASS_DIGITIZER, /* digitizer class */ /* Don't forget to change the following: */ SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, }; enum { SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */ SNDRV_PCM_SUBCLASS_MULTI_MIX, /* multichannel subdevices are mixed together */ /* Don't forget to change the following: */ SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, }; enum { SNDRV_PCM_STREAM_PLAYBACK = 0, SNDRV_PCM_STREAM_CAPTURE, SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, }; typedef int __bitwise snd_pcm_access_t; #define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((snd_pcm_access_t) 0) /* interleaved mmap */ #define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((snd_pcm_access_t) 1) /* noninterleaved mmap */ #define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((snd_pcm_access_t) 2) /* complex mmap */ #define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((snd_pcm_access_t) 3) /* readi/writei */ #define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((snd_pcm_access_t) 4) /* readn/writen */ #define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED typedef int __bitwise snd_pcm_format_t; #define SNDRV_PCM_FORMAT_S8 ((snd_pcm_format_t) 0) #define SNDRV_PCM_FORMAT_U8 ((snd_pcm_format_t) 1) #define SNDRV_PCM_FORMAT_S16_LE ((snd_pcm_format_t) 2) #define SNDRV_PCM_FORMAT_S16_BE ((snd_pcm_format_t) 3) #define SNDRV_PCM_FORMAT_U16_LE ((snd_pcm_format_t) 4) #define SNDRV_PCM_FORMAT_U16_BE ((snd_pcm_format_t) 5) #define SNDRV_PCM_FORMAT_S24_LE ((snd_pcm_format_t) 6) /* low three bytes */ #define SNDRV_PCM_FORMAT_S24_BE ((snd_pcm_format_t) 7) /* low three bytes */ #define SNDRV_PCM_FORMAT_U24_LE ((snd_pcm_format_t) 8) /* low three bytes */ #define SNDRV_PCM_FORMAT_U24_BE ((snd_pcm_format_t) 9) /* low three bytes */ /* * For S32/U32 formats, 'msbits' hardware parameter is often used to deliver information about the * available bit count in most significant bit. It's for the case of so-called 'left-justified' or * `right-padding` sample which has less width than 32 bit. */ #define SNDRV_PCM_FORMAT_S32_LE ((snd_pcm_format_t) 10) #define SNDRV_PCM_FORMAT_S32_BE ((snd_pcm_format_t) 11) #define SNDRV_PCM_FORMAT_U32_LE ((snd_pcm_format_t) 12) #define SNDRV_PCM_FORMAT_U32_BE ((snd_pcm_format_t) 13) #define SNDRV_PCM_FORMAT_FLOAT_LE ((snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ #define SNDRV_PCM_FORMAT_FLOAT_BE ((snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ #define SNDRV_PCM_FORMAT_FLOAT64_LE ((snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ #define SNDRV_PCM_FORMAT_FLOAT64_BE ((snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */ #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */ #define SNDRV_PCM_FORMAT_MU_LAW ((snd_pcm_format_t) 20) #define SNDRV_PCM_FORMAT_A_LAW ((snd_pcm_format_t) 21) #define SNDRV_PCM_FORMAT_IMA_ADPCM ((snd_pcm_format_t) 22) #define SNDRV_PCM_FORMAT_MPEG ((snd_pcm_format_t) 23) #define SNDRV_PCM_FORMAT_GSM ((snd_pcm_format_t) 24) #define SNDRV_PCM_FORMAT_S20_LE ((snd_pcm_format_t) 25) /* in four bytes, LSB justified */ #define SNDRV_PCM_FORMAT_S20_BE ((snd_pcm_format_t) 26) /* in four bytes, LSB justified */ #define SNDRV_PCM_FORMAT_U20_LE ((snd_pcm_format_t) 27) /* in four bytes, LSB justified */ #define SNDRV_PCM_FORMAT_U20_BE ((snd_pcm_format_t) 28) /* in four bytes, LSB justified */ /* gap in the numbering for a future standard linear format */ #define SNDRV_PCM_FORMAT_SPECIAL ((snd_pcm_format_t) 31) #define SNDRV_PCM_FORMAT_S24_3LE ((snd_pcm_format_t) 32) /* in three bytes */ #define SNDRV_PCM_FORMAT_S24_3BE ((snd_pcm_format_t) 33) /* in three bytes */ #define SNDRV_PCM_FORMAT_U24_3LE ((snd_pcm_format_t) 34) /* in three bytes */ #define SNDRV_PCM_FORMAT_U24_3BE ((snd_pcm_format_t) 35) /* in three bytes */ #define SNDRV_PCM_FORMAT_S20_3LE ((snd_pcm_format_t) 36) /* in three bytes */ #define SNDRV_PCM_FORMAT_S20_3BE ((snd_pcm_format_t) 37) /* in three bytes */ #define SNDRV_PCM_FORMAT_U20_3LE ((snd_pcm_format_t) 38) /* in three bytes */ #define SNDRV_PCM_FORMAT_U20_3BE ((snd_pcm_format_t) 39) /* in three bytes */ #define SNDRV_PCM_FORMAT_S18_3LE ((snd_pcm_format_t) 40) /* in three bytes */ #define SNDRV_PCM_FORMAT_S18_3BE ((snd_pcm_format_t) 41) /* in three bytes */ #define SNDRV_PCM_FORMAT_U18_3LE ((snd_pcm_format_t) 42) /* in three bytes */ #define SNDRV_PCM_FORMAT_U18_3BE ((snd_pcm_format_t) 43) /* in three bytes */ #define SNDRV_PCM_FORMAT_G723_24 ((snd_pcm_format_t) 44) /* 8 samples in 3 bytes */ #define SNDRV_PCM_FORMAT_G723_24_1B ((snd_pcm_format_t) 45) /* 1 sample in 1 byte */ #define SNDRV_PCM_FORMAT_G723_40 ((snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */ #define SNDRV_PCM_FORMAT_G723_40_1B ((snd_pcm_format_t) 47) /* 1 sample in 1 byte */ #define SNDRV_PCM_FORMAT_DSD_U8 ((snd_pcm_format_t) 48) /* DSD, 1-byte samples DSD (x8) */ #define SNDRV_PCM_FORMAT_DSD_U16_LE ((snd_pcm_format_t) 49) /* DSD, 2-byte samples DSD (x16), little endian */ #define SNDRV_PCM_FORMAT_DSD_U32_LE ((snd_pcm_format_t) 50) /* DSD, 4-byte samples DSD (x32), little endian */ #define SNDRV_PCM_FORMAT_DSD_U16_BE ((snd_pcm_format_t) 51) /* DSD, 2-byte samples DSD (x16), big endian */ #define SNDRV_PCM_FORMAT_DSD_U32_BE ((snd_pcm_format_t) 52) /* DSD, 4-byte samples DSD (x32), big endian */ #define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_DSD_U32_BE #define SNDRV_PCM_FORMAT_FIRST SNDRV_PCM_FORMAT_S8 #ifdef SNDRV_LITTLE_ENDIAN #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE #define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_LE #define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_LE #endif #ifdef SNDRV_BIG_ENDIAN #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE #define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_BE #define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_BE #endif typedef int __bitwise snd_pcm_subformat_t; #define SNDRV_PCM_SUBFORMAT_STD ((snd_pcm_subformat_t) 0) #define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_STD #define SNDRV_PCM_INFO_MMAP 0x00000001 /* hardware supports mmap */ #define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 /* period data are valid during transfer */ #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ #define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ #define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 /* hardware transfer block of samples */ #define SNDRV_PCM_INFO_OVERRANGE 0x00020000 /* hardware supports ADC (capture) overrange detection */ #define SNDRV_PCM_INFO_RESUME 0x00040000 /* hardware supports stream resume after suspend */ #define SNDRV_PCM_INFO_PAUSE 0x00080000 /* pause ioctl is supported */ #define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 /* only half duplex */ #define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 /* playback and capture stream are somewhat correlated */ #define SNDRV_PCM_INFO_SYNC_START 0x00400000 /* pcm support some kind of sync go */ #define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000 /* period wakeup can be disabled */ #define SNDRV_PCM_INFO_HAS_WALL_CLOCK 0x01000000 /* (Deprecated)has audio wall clock for audio/system time sync */ #define SNDRV_PCM_INFO_HAS_LINK_ATIME 0x01000000 /* report hardware link audio time, reset on startup */ #define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME 0x02000000 /* report absolute hardware link audio time, not reset on startup */ #define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 /* report estimated link audio time */ #define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 /* report synchronized audio/system time */ #define SNDRV_PCM_INFO_EXPLICIT_SYNC 0x10000000 /* needs explicit sync of pointers and data */ #define SNDRV_PCM_INFO_NO_REWINDS 0x20000000 /* hardware can only support monotonic changes of appl_ptr */ #define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 /* internal kernel flag - trigger in drain */ #define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 /* internal kernel flag - FIFO size is in frames */ #if (__BITS_PER_LONG == 32 && defined(__USE_TIME_BITS64)) || defined __KERNEL__ #define __SND_STRUCT_TIME64 #endif typedef int __bitwise snd_pcm_state_t; #define SNDRV_PCM_STATE_OPEN ((snd_pcm_state_t) 0) /* stream is open */ #define SNDRV_PCM_STATE_SETUP ((snd_pcm_state_t) 1) /* stream has a setup */ #define SNDRV_PCM_STATE_PREPARED ((snd_pcm_state_t) 2) /* stream is ready to start */ #define SNDRV_PCM_STATE_RUNNING ((snd_pcm_state_t) 3) /* stream is running */ #define SNDRV_PCM_STATE_XRUN ((snd_pcm_state_t) 4) /* stream reached an xrun */ #define SNDRV_PCM_STATE_DRAINING ((snd_pcm_state_t) 5) /* stream is draining */ #define SNDRV_PCM_STATE_PAUSED ((snd_pcm_state_t) 6) /* stream is paused */ #define SNDRV_PCM_STATE_SUSPENDED ((snd_pcm_state_t) 7) /* hardware is suspended */ #define SNDRV_PCM_STATE_DISCONNECTED ((snd_pcm_state_t) 8) /* hardware is disconnected */ #define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED enum { SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, SNDRV_PCM_MMAP_OFFSET_STATUS_OLD = 0x80000000, SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD = 0x81000000, SNDRV_PCM_MMAP_OFFSET_STATUS_NEW = 0x82000000, SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW = 0x83000000, #ifdef __SND_STRUCT_TIME64 SNDRV_PCM_MMAP_OFFSET_STATUS = SNDRV_PCM_MMAP_OFFSET_STATUS_NEW, SNDRV_PCM_MMAP_OFFSET_CONTROL = SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW, #else SNDRV_PCM_MMAP_OFFSET_STATUS = SNDRV_PCM_MMAP_OFFSET_STATUS_OLD, SNDRV_PCM_MMAP_OFFSET_CONTROL = SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD, #endif }; union snd_pcm_sync_id { unsigned char id[16]; unsigned short id16[8]; unsigned int id32[4]; }; struct snd_pcm_info { unsigned int device; /* RO/WR (control): device number */ unsigned int subdevice; /* RO/WR (control): subdevice number */ int stream; /* RO/WR (control): stream direction */ int card; /* R: card number */ unsigned char id[64]; /* ID (user selectable) */ unsigned char name[80]; /* name of this device */ unsigned char subname[32]; /* subdevice name */ int dev_class; /* SNDRV_PCM_CLASS_* */ int dev_subclass; /* SNDRV_PCM_SUBCLASS_* */ unsigned int subdevices_count; unsigned int subdevices_avail; union snd_pcm_sync_id sync; /* hardware synchronization ID */ unsigned char reserved[64]; /* reserved for future... */ }; typedef int snd_pcm_hw_param_t; #define SNDRV_PCM_HW_PARAM_ACCESS 0 /* Access type */ #define SNDRV_PCM_HW_PARAM_FORMAT 1 /* Format */ #define SNDRV_PCM_HW_PARAM_SUBFORMAT 2 /* Subformat */ #define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS #define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT #define SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8 /* Bits per sample */ #define SNDRV_PCM_HW_PARAM_FRAME_BITS 9 /* Bits per frame */ #define SNDRV_PCM_HW_PARAM_CHANNELS 10 /* Channels */ #define SNDRV_PCM_HW_PARAM_RATE 11 /* Approx rate */ #define SNDRV_PCM_HW_PARAM_PERIOD_TIME 12 /* Approx distance between * interrupts in us */ #define SNDRV_PCM_HW_PARAM_PERIOD_SIZE 13 /* Approx frames between * interrupts */ #define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14 /* Approx bytes between * interrupts */ #define SNDRV_PCM_HW_PARAM_PERIODS 15 /* Approx interrupts per * buffer */ #define SNDRV_PCM_HW_PARAM_BUFFER_TIME 16 /* Approx duration of buffer * in us */ #define SNDRV_PCM_HW_PARAM_BUFFER_SIZE 17 /* Size of buffer in frames */ #define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18 /* Size of buffer in bytes */ #define SNDRV_PCM_HW_PARAM_TICK_TIME 19 /* Approx tick duration in us */ #define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS #define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ #define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling * of the silence samples */ struct snd_interval { unsigned int min, max; unsigned int openmin:1, openmax:1, integer:1, empty:1; }; #define SNDRV_MASK_MAX 256 struct snd_mask { __u32 bits[(SNDRV_MASK_MAX+31)/32]; }; struct snd_pcm_hw_params { unsigned int flags; struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; struct snd_mask mres[5]; /* reserved masks */ struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; struct snd_interval ires[9]; /* reserved intervals */ unsigned int rmask; /* W: requested masks */ unsigned int cmask; /* R: changed masks */ unsigned int info; /* R: Info flags for returned setup */ unsigned int msbits; /* R: used most significant bits */ unsigned int rate_num; /* R: rate numerator */ unsigned int rate_den; /* R: rate denominator */ snd_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */ unsigned char reserved[64]; /* reserved for future */ }; enum { SNDRV_PCM_TSTAMP_NONE = 0, SNDRV_PCM_TSTAMP_ENABLE, SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE, }; struct snd_pcm_sw_params { int tstamp_mode; /* timestamp mode */ unsigned int period_step; unsigned int sleep_min; /* min ticks to sleep */ snd_pcm_uframes_t avail_min; /* min avail frames for wakeup */ snd_pcm_uframes_t xfer_align; /* obsolete: xfer size need to be a multiple */ snd_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */ /* * The following two thresholds alleviate playback buffer underruns; when * hw_avail drops below the threshold, the respective action is triggered: */ snd_pcm_uframes_t stop_threshold; /* - stop playback */ snd_pcm_uframes_t silence_threshold; /* - pre-fill buffer with silence */ snd_pcm_uframes_t silence_size; /* max size of silence pre-fill; when >= boundary, * fill played area with silence immediately */ snd_pcm_uframes_t boundary; /* pointers wrap point */ unsigned int proto; /* protocol version */ unsigned int tstamp_type; /* timestamp type (req. proto >= 2.0.12) */ unsigned char reserved[56]; /* reserved for future */ }; struct snd_pcm_channel_info { unsigned int channel; __kernel_off_t offset; /* mmap offset */ unsigned int first; /* offset to first sample in bits */ unsigned int step; /* samples distance in bits */ }; enum { /* * first definition for backwards compatibility only, * maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0, /* timestamp definitions */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1, /* DMA time, reported as per hw_ptr */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2, /* link time reported by sample or wallclock counter, reset on startup */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3, /* link time reported by sample or wallclock counter, not reset on startup */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4, /* link time estimated indirectly */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /* link time synchronized with system time */ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED }; /* explicit padding avoids incompatibility between i386 and x86-64 */ typedef struct { unsigned char pad[sizeof(time_t) - sizeof(int)]; } __time_pad; struct snd_pcm_status { snd_pcm_state_t state; /* stream state */ __time_pad pad1; /* align to timespec */ struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */ struct timespec tstamp; /* reference timestamp */ snd_pcm_uframes_t appl_ptr; /* appl ptr */ snd_pcm_uframes_t hw_ptr; /* hw ptr */ snd_pcm_sframes_t delay; /* current delay in frames */ snd_pcm_uframes_t avail; /* number of frames available */ snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */ snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ snd_pcm_state_t suspended_state; /* suspended stream state */ __u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */ struct timespec audio_tstamp; /* sample counter, wall clock, PHC or on-demand sync'ed */ struct timespec driver_tstamp; /* useful in case reference system tstamp is reported with delay */ __u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */ unsigned char reserved[52-2*sizeof(struct timespec)]; /* must be filled with zero */ }; /* * For mmap operations, we need the 64-bit layout, both for compat mode, * and for y2038 compatibility. For 64-bit applications, the two definitions * are identical, so we keep the traditional version. */ #ifdef __SND_STRUCT_TIME64 #define __snd_pcm_mmap_status64 snd_pcm_mmap_status #define __snd_pcm_mmap_control64 snd_pcm_mmap_control #define __snd_pcm_sync_ptr64 snd_pcm_sync_ptr #define __snd_timespec64 timespec struct __snd_timespec { __s32 tv_sec; __s32 tv_nsec; }; #else #define __snd_pcm_mmap_status snd_pcm_mmap_status #define __snd_pcm_mmap_control snd_pcm_mmap_control #define __snd_pcm_sync_ptr snd_pcm_sync_ptr #define __snd_timespec timespec struct __snd_timespec64 { __s64 tv_sec; __s64 tv_nsec; }; #endif struct __snd_pcm_mmap_status { snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */ int pad1; /* Needed for 64 bit alignment */ snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ struct __snd_timespec tstamp; /* Timestamp */ snd_pcm_state_t suspended_state; /* RO: suspended stream state */ struct __snd_timespec audio_tstamp; /* from sample counter or wall clock */ }; struct __snd_pcm_mmap_control { snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ }; #define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) /* execute hwsync */ #define SNDRV_PCM_SYNC_PTR_APPL (1<<1) /* get appl_ptr from driver (r/w op) */ #define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) /* get avail_min from driver */ struct __snd_pcm_sync_ptr { unsigned int flags; union { struct __snd_pcm_mmap_status status; unsigned char reserved[64]; } s; union { struct __snd_pcm_mmap_control control; unsigned char reserved[64]; } c; }; #if defined(__BYTE_ORDER) ? __BYTE_ORDER == __BIG_ENDIAN : defined(__BIG_ENDIAN) typedef char __pad_before_uframe[sizeof(__u64) - sizeof(snd_pcm_uframes_t)]; typedef char __pad_after_uframe[0]; #endif #if defined(__BYTE_ORDER) ? __BYTE_ORDER == __LITTLE_ENDIAN : defined(__LITTLE_ENDIAN) typedef char __pad_before_uframe[0]; typedef char __pad_after_uframe[sizeof(__u64) - sizeof(snd_pcm_uframes_t)]; #endif struct __snd_pcm_mmap_status64 { snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */ __u32 pad1; /* Needed for 64 bit alignment */ __pad_before_uframe __pad1; snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ __pad_after_uframe __pad2; struct __snd_timespec64 tstamp; /* Timestamp */ snd_pcm_state_t suspended_state;/* RO: suspended stream state */ __u32 pad3; /* Needed for 64 bit alignment */ struct __snd_timespec64 audio_tstamp; /* sample counter or wall clock */ }; struct __snd_pcm_mmap_control64 { __pad_before_uframe __pad1; snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ __pad_before_uframe __pad2; // This should be __pad_after_uframe, but binary // backwards compatibility constraints prevent a fix. __pad_before_uframe __pad3; snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ __pad_after_uframe __pad4; }; struct __snd_pcm_sync_ptr64 { __u32 flags; __u32 pad1; union { struct __snd_pcm_mmap_status64 status; unsigned char reserved[64]; } s; union { struct __snd_pcm_mmap_control64 control; unsigned char reserved[64]; } c; }; struct snd_xferi { snd_pcm_sframes_t result; void *buf; snd_pcm_uframes_t frames; }; struct snd_xfern { snd_pcm_sframes_t result; void * *bufs; snd_pcm_uframes_t frames; }; enum { SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, /* gettimeofday equivalent */ SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, /* posix_clock_monotonic equivalent */ SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, /* monotonic_raw (no NTP) */ SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, }; /* channel positions */ enum { SNDRV_CHMAP_UNKNOWN = 0, SNDRV_CHMAP_NA, /* N/A, silent */ SNDRV_CHMAP_MONO, /* mono stream */ /* this follows the alsa-lib mixer channel value + 3 */ SNDRV_CHMAP_FL, /* front left */ SNDRV_CHMAP_FR, /* front right */ SNDRV_CHMAP_RL, /* rear left */ SNDRV_CHMAP_RR, /* rear right */ SNDRV_CHMAP_FC, /* front center */ SNDRV_CHMAP_LFE, /* LFE */ SNDRV_CHMAP_SL, /* side left */ SNDRV_CHMAP_SR, /* side right */ SNDRV_CHMAP_RC, /* rear center */ /* new definitions */ SNDRV_CHMAP_FLC, /* front left center */ SNDRV_CHMAP_FRC, /* front right center */ SNDRV_CHMAP_RLC, /* rear left center */ SNDRV_CHMAP_RRC, /* rear right center */ SNDRV_CHMAP_FLW, /* front left wide */ SNDRV_CHMAP_FRW, /* front right wide */ SNDRV_CHMAP_FLH, /* front left high */ SNDRV_CHMAP_FCH, /* front center high */ SNDRV_CHMAP_FRH, /* front right high */ SNDRV_CHMAP_TC, /* top center */ SNDRV_CHMAP_TFL, /* top front left */ SNDRV_CHMAP_TFR, /* top front right */ SNDRV_CHMAP_TFC, /* top front center */ SNDRV_CHMAP_TRL, /* top rear left */ SNDRV_CHMAP_TRR, /* top rear right */ SNDRV_CHMAP_TRC, /* top rear center */ /* new definitions for UAC2 */ SNDRV_CHMAP_TFLC, /* top front left center */ SNDRV_CHMAP_TFRC, /* top front right center */ SNDRV_CHMAP_TSL, /* top side left */ SNDRV_CHMAP_TSR, /* top side right */ SNDRV_CHMAP_LLFE, /* left LFE */ SNDRV_CHMAP_RLFE, /* right LFE */ SNDRV_CHMAP_BC, /* bottom center */ SNDRV_CHMAP_BLC, /* bottom left center */ SNDRV_CHMAP_BRC, /* bottom right center */ SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC, }; #define SNDRV_CHMAP_POSITION_MASK 0xffff #define SNDRV_CHMAP_PHASE_INVERSE (0x01 << 16) #define SNDRV_CHMAP_DRIVER_SPEC (0x02 << 16) #define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int) #define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct snd_pcm_info) #define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int) #define SNDRV_PCM_IOCTL_TTSTAMP _IOW('A', 0x03, int) #define SNDRV_PCM_IOCTL_USER_PVERSION _IOW('A', 0x04, int) #define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct snd_pcm_hw_params) #define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct snd_pcm_hw_params) #define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12) #define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct snd_pcm_sw_params) #define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct snd_pcm_status) #define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, snd_pcm_sframes_t) #define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22) #define __SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct __snd_pcm_sync_ptr) #define __SNDRV_PCM_IOCTL_SYNC_PTR64 _IOWR('A', 0x23, struct __snd_pcm_sync_ptr64) #define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct snd_pcm_sync_ptr) #define SNDRV_PCM_IOCTL_STATUS_EXT _IOWR('A', 0x24, struct snd_pcm_status) #define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct snd_pcm_channel_info) #define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40) #define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41) #define SNDRV_PCM_IOCTL_START _IO('A', 0x42) #define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43) #define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44) #define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int) #define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, snd_pcm_uframes_t) #define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47) #define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48) #define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, snd_pcm_uframes_t) #define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct snd_xferi) #define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct snd_xferi) #define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct snd_xfern) #define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct snd_xfern) #define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int) #define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61) /***************************************************************************** * * * MIDI v1.0 interface * * * *****************************************************************************/ /* * Raw MIDI section - /dev/snd/midi?? */ #define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) enum { SNDRV_RAWMIDI_STREAM_OUTPUT = 0, SNDRV_RAWMIDI_STREAM_INPUT, SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, }; #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 struct snd_rawmidi_info { unsigned int device; /* RO/WR (control): device number */ unsigned int subdevice; /* RO/WR (control): subdevice number */ int stream; /* WR: stream */ int card; /* R: card number */ unsigned int flags; /* SNDRV_RAWMIDI_INFO_XXXX */ unsigned char id[64]; /* ID (user selectable) */ unsigned char name[80]; /* name of device */ unsigned char subname[32]; /* name of active or selected subdevice */ unsigned int subdevices_count; unsigned int subdevices_avail; unsigned char reserved[64]; /* reserved for future use */ }; #define SNDRV_RAWMIDI_MODE_FRAMING_MASK (7<<0) #define SNDRV_RAWMIDI_MODE_FRAMING_SHIFT 0 #define SNDRV_RAWMIDI_MODE_FRAMING_NONE (0<<0) #define SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP (1<<0) #define SNDRV_RAWMIDI_MODE_CLOCK_MASK (7<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_SHIFT 3 #define SNDRV_RAWMIDI_MODE_CLOCK_NONE (0<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_REALTIME (1<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC (2<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW (3<<3) #define SNDRV_RAWMIDI_FRAMING_DATA_LENGTH 16 struct snd_rawmidi_framing_tstamp { /* For now, frame_type is always 0. Midi 2.0 is expected to add new * types here. Applications are expected to skip unknown frame types. */ __u8 frame_type; __u8 length; /* number of valid bytes in data field */ __u8 reserved[2]; __u32 tv_nsec; /* nanoseconds */ __u64 tv_sec; /* seconds */ __u8 data[SNDRV_RAWMIDI_FRAMING_DATA_LENGTH]; } __attribute__((packed)); struct snd_rawmidi_params { int stream; size_t buffer_size; /* queue size in bytes */ size_t avail_min; /* minimum avail bytes for wakeup */ unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */ unsigned int mode; /* For input data only, frame incoming data */ unsigned char reserved[12]; /* reserved for future use */ }; struct snd_rawmidi_status { int stream; __time_pad pad1; struct timespec tstamp; /* Timestamp */ size_t avail; /* available bytes */ size_t xruns; /* count of overruns since last status (in bytes) */ unsigned char reserved[16]; /* reserved for future use */ }; #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) #define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct snd_rawmidi_params) #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) /* * Timer section - /dev/snd/timer */ #define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 7) enum { SNDRV_TIMER_CLASS_NONE = -1, SNDRV_TIMER_CLASS_SLAVE = 0, SNDRV_TIMER_CLASS_GLOBAL, SNDRV_TIMER_CLASS_CARD, SNDRV_TIMER_CLASS_PCM, SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM, }; /* slave timer classes */ enum { SNDRV_TIMER_SCLASS_NONE = 0, SNDRV_TIMER_SCLASS_APPLICATION, SNDRV_TIMER_SCLASS_SEQUENCER, /* alias */ SNDRV_TIMER_SCLASS_OSS_SEQUENCER, /* alias */ SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, }; /* global timers (device member) */ #define SNDRV_TIMER_GLOBAL_SYSTEM 0 #define SNDRV_TIMER_GLOBAL_RTC 1 /* unused */ #define SNDRV_TIMER_GLOBAL_HPET 2 #define SNDRV_TIMER_GLOBAL_HRTIMER 3 /* info flags */ #define SNDRV_TIMER_FLG_SLAVE (1<<0) /* cannot be controlled */ struct snd_timer_id { int dev_class; int dev_sclass; int card; int device; int subdevice; }; struct snd_timer_ginfo { struct snd_timer_id tid; /* requested timer ID */ unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ int card; /* card number */ unsigned char id[64]; /* timer identification */ unsigned char name[80]; /* timer name */ unsigned long reserved0; /* reserved for future use */ unsigned long resolution; /* average period resolution in ns */ unsigned long resolution_min; /* minimal period resolution in ns */ unsigned long resolution_max; /* maximal period resolution in ns */ unsigned int clients; /* active timer clients */ unsigned char reserved[32]; }; struct snd_timer_gparams { struct snd_timer_id tid; /* requested timer ID */ unsigned long period_num; /* requested precise period duration (in seconds) - numerator */ unsigned long period_den; /* requested precise period duration (in seconds) - denominator */ unsigned char reserved[32]; }; struct snd_timer_gstatus { struct snd_timer_id tid; /* requested timer ID */ unsigned long resolution; /* current period resolution in ns */ unsigned long resolution_num; /* precise current period resolution (in seconds) - numerator */ unsigned long resolution_den; /* precise current period resolution (in seconds) - denominator */ unsigned char reserved[32]; }; struct snd_timer_select { struct snd_timer_id id; /* bind to timer ID */ unsigned char reserved[32]; /* reserved */ }; struct snd_timer_info { unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ int card; /* card number */ unsigned char id[64]; /* timer identificator */ unsigned char name[80]; /* timer name */ unsigned long reserved0; /* reserved for future use */ unsigned long resolution; /* average period resolution in ns */ unsigned char reserved[64]; /* reserved */ }; #define SNDRV_TIMER_PSFLG_AUTO (1<<0) /* auto start, otherwise one-shot */ #define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) /* exclusive use, precise start/stop/pause/continue */ #define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) /* write early event to the poll queue */ struct snd_timer_params { unsigned int flags; /* flags - SNDRV_TIMER_PSFLG_* */ unsigned int ticks; /* requested resolution in ticks */ unsigned int queue_size; /* total size of queue (32-1024) */ unsigned int reserved0; /* reserved, was: failure locations */ unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */ unsigned char reserved[60]; /* reserved */ }; struct snd_timer_status { struct timespec tstamp; /* Timestamp - last update */ unsigned int resolution; /* current period resolution in ns */ unsigned int lost; /* counter of master tick lost */ unsigned int overrun; /* count of read queue overruns */ unsigned int queue; /* used queue size */ unsigned char reserved[64]; /* reserved */ }; #define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int) #define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct snd_timer_id) #define SNDRV_TIMER_IOCTL_TREAD_OLD _IOW('T', 0x02, int) #define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct snd_timer_ginfo) #define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct snd_timer_gparams) #define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct snd_timer_gstatus) #define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct snd_timer_select) #define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct snd_timer_info) #define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct snd_timer_params) #define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct snd_timer_status) /* The following four ioctls are changed since 1.0.9 due to confliction */ #define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0) #define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1) #define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2) #define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3) #define SNDRV_TIMER_IOCTL_TREAD64 _IOW('T', 0xa4, int) #if __BITS_PER_LONG == 64 #define SNDRV_TIMER_IOCTL_TREAD SNDRV_TIMER_IOCTL_TREAD_OLD #else #define SNDRV_TIMER_IOCTL_TREAD ((sizeof(__kernel_long_t) >= sizeof(time_t)) ? \ SNDRV_TIMER_IOCTL_TREAD_OLD : \ SNDRV_TIMER_IOCTL_TREAD64) #endif struct snd_timer_read { unsigned int resolution; unsigned int ticks; }; enum { SNDRV_TIMER_EVENT_RESOLUTION = 0, /* val = resolution in ns */ SNDRV_TIMER_EVENT_TICK, /* val = ticks */ SNDRV_TIMER_EVENT_START, /* val = resolution in ns */ SNDRV_TIMER_EVENT_STOP, /* val = 0 */ SNDRV_TIMER_EVENT_CONTINUE, /* val = resolution in ns */ SNDRV_TIMER_EVENT_PAUSE, /* val = 0 */ SNDRV_TIMER_EVENT_EARLY, /* val = 0, early event */ SNDRV_TIMER_EVENT_SUSPEND, /* val = 0 */ SNDRV_TIMER_EVENT_RESUME, /* val = resolution in ns */ /* master timer events for slave timer instances */ SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10, SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10, SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10, SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10, SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10, SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, }; struct snd_timer_tread { int event; __time_pad pad1; struct timespec tstamp; unsigned int val; __time_pad pad2; }; /**************************************************************************** * * * Section for driver control interface - /dev/snd/control? * * * ****************************************************************************/ #define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) struct snd_ctl_card_info { int card; /* card number */ int pad; /* reserved for future (was type) */ unsigned char id[16]; /* ID of card (user selectable) */ unsigned char driver[16]; /* Driver name */ unsigned char name[32]; /* Short name of soundcard */ unsigned char longname[80]; /* name + info text about soundcard */ unsigned char reserved_[16]; /* reserved for future (was ID of mixer) */ unsigned char mixername[80]; /* visual mixer identification */ unsigned char components[128]; /* card components / fine identification, delimited with one space (AC97 etc..) */ }; typedef int __bitwise snd_ctl_elem_type_t; #define SNDRV_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t) 0) /* invalid */ #define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((snd_ctl_elem_type_t) 1) /* boolean type */ #define SNDRV_CTL_ELEM_TYPE_INTEGER ((snd_ctl_elem_type_t) 2) /* integer type */ #define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((snd_ctl_elem_type_t) 3) /* enumerated type */ #define SNDRV_CTL_ELEM_TYPE_BYTES ((snd_ctl_elem_type_t) 4) /* byte array */ #define SNDRV_CTL_ELEM_TYPE_IEC958 ((snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */ #define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((snd_ctl_elem_type_t) 6) /* 64-bit integer type */ #define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 typedef int __bitwise snd_ctl_elem_iface_t; #define SNDRV_CTL_ELEM_IFACE_CARD ((snd_ctl_elem_iface_t) 0) /* global control */ #define SNDRV_CTL_ELEM_IFACE_HWDEP ((snd_ctl_elem_iface_t) 1) /* hardware dependent device */ #define SNDRV_CTL_ELEM_IFACE_MIXER ((snd_ctl_elem_iface_t) 2) /* virtual mixer device */ #define SNDRV_CTL_ELEM_IFACE_PCM ((snd_ctl_elem_iface_t) 3) /* PCM device */ #define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((snd_ctl_elem_iface_t) 4) /* RawMidi device */ #define SNDRV_CTL_ELEM_IFACE_TIMER ((snd_ctl_elem_iface_t) 5) /* timer device */ #define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((snd_ctl_elem_iface_t) 6) /* sequencer client */ #define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER #define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) #define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) #define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE) #define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) /* control value may be changed without a notification */ /* (1 << 3) is unused. */ #define SNDRV_CTL_ELEM_ACCESS_TLV_READ (1<<4) /* TLV read is possible */ #define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1<<5) /* TLV write is possible */ #define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE (SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) #define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1<<6) /* TLV command is possible */ #define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */ #define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */ #define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */ #define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) /* kernel use a TLV callback */ #define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) /* user space element */ /* bits 30 and 31 are obsoleted (for indirect access) */ /* for further details see the ACPI and PCI power management specification */ #define SNDRV_CTL_POWER_D0 0x0000 /* full On */ #define SNDRV_CTL_POWER_D1 0x0100 /* partial On */ #define SNDRV_CTL_POWER_D2 0x0200 /* partial On */ #define SNDRV_CTL_POWER_D3 0x0300 /* Off */ #define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) /* Off, with power */ #define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) /* Off, without power */ #define SNDRV_CTL_ELEM_ID_NAME_MAXLEN 44 struct snd_ctl_elem_id { unsigned int numid; /* numeric identifier, zero = invalid */ snd_ctl_elem_iface_t iface; /* interface identifier */ unsigned int device; /* device/client number */ unsigned int subdevice; /* subdevice (substream) number */ unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* ASCII name of item */ unsigned int index; /* index of item */ }; struct snd_ctl_elem_list { unsigned int offset; /* W: first element ID to get */ unsigned int space; /* W: count of element IDs to get */ unsigned int used; /* R: count of element IDs set */ unsigned int count; /* R: count of all elements */ struct snd_ctl_elem_id *pids; /* R: IDs */ unsigned char reserved[50]; }; struct snd_ctl_elem_info { struct snd_ctl_elem_id id; /* W: element ID */ snd_ctl_elem_type_t type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */ unsigned int access; /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */ unsigned int count; /* count of values */ __kernel_pid_t owner; /* owner's PID of this control */ union { struct { long min; /* R: minimum value */ long max; /* R: maximum value */ long step; /* R: step (0 variable) */ } integer; struct { long long min; /* R: minimum value */ long long max; /* R: maximum value */ long long step; /* R: step (0 variable) */ } integer64; struct { unsigned int items; /* R: number of items */ unsigned int item; /* W: item number */ char name[64]; /* R: value name */ __u64 names_ptr; /* W: names list (ELEM_ADD only) */ unsigned int names_length; } enumerated; unsigned char reserved[128]; } value; unsigned char reserved[64]; }; struct snd_ctl_elem_value { struct snd_ctl_elem_id id; /* W: element ID */ unsigned int indirect: 1; /* W: indirect access - obsoleted */ union { union { long value[128]; long *value_ptr; /* obsoleted */ } integer; union { long long value[64]; long long *value_ptr; /* obsoleted */ } integer64; union { unsigned int item[128]; unsigned int *item_ptr; /* obsoleted */ } enumerated; union { unsigned char data[512]; unsigned char *data_ptr; /* obsoleted */ } bytes; struct snd_aes_iec958 iec958; } value; /* RO */ unsigned char reserved[128]; }; struct snd_ctl_tlv { unsigned int numid; /* control element numeric identification */ unsigned int length; /* in bytes aligned to 4 */ unsigned int tlv[0]; /* first TLV */ }; #define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int) #define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct snd_ctl_card_info) #define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct snd_ctl_elem_list) #define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct snd_ctl_elem_value) #define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct snd_ctl_elem_value) #define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int) #define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int) #define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct snd_hwdep_info) #define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int) #define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct snd_pcm_info) #define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int) #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) /* * Read interface. */ enum sndrv_ctl_event_type { SNDRV_CTL_EVENT_ELEM = 0, SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM, }; #define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) /* element value was changed */ #define SNDRV_CTL_EVENT_MASK_INFO (1<<1) /* element info was changed */ #define SNDRV_CTL_EVENT_MASK_ADD (1<<2) /* element was added */ #define SNDRV_CTL_EVENT_MASK_TLV (1<<3) /* element TLV tree was changed */ #define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) /* element was removed */ struct snd_ctl_event { int type; /* event type - SNDRV_CTL_EVENT_* */ union { struct { unsigned int mask; struct snd_ctl_elem_id id; } elem; unsigned char data8[60]; } data; }; /* * Control names */ #define SNDRV_CTL_NAME_NONE "" #define SNDRV_CTL_NAME_PLAYBACK "Playback " #define SNDRV_CTL_NAME_CAPTURE "Capture " #define SNDRV_CTL_NAME_IEC958_NONE "" #define SNDRV_CTL_NAME_IEC958_SWITCH "Switch" #define SNDRV_CTL_NAME_IEC958_VOLUME "Volume" #define SNDRV_CTL_NAME_IEC958_DEFAULT "Default" #define SNDRV_CTL_NAME_IEC958_MASK "Mask" #define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask" #define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask" #define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream" #define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what #endif /* __SOUND_ASOUND_H */ sound/sfnt_info.h000064400000015142152640040150010032 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ #ifndef __SOUND_SFNT_INFO_H #define __SOUND_SFNT_INFO_H /* * Patch record compatible with AWE driver on OSS * * Copyright (C) 1999-2000 Takashi Iwai */ #include /* * patch information record */ #ifdef SNDRV_BIG_ENDIAN #define SNDRV_OSS_PATCHKEY(id) (0xfd00|id) #else #define SNDRV_OSS_PATCHKEY(id) ((id<<8)|0xfd) #endif /* patch interface header: 16 bytes */ struct soundfont_patch_info { unsigned short key; /* use the key below */ #define SNDRV_OSS_SOUNDFONT_PATCH SNDRV_OSS_PATCHKEY(0x07) short device_no; /* synthesizer number */ unsigned short sf_id; /* file id (should be zero) */ short optarg; /* optional argument */ int len; /* data length (without this header) */ short type; /* patch operation type */ #define SNDRV_SFNT_LOAD_INFO 0 /* awe_voice_rec */ #define SNDRV_SFNT_LOAD_DATA 1 /* awe_sample_info */ #define SNDRV_SFNT_OPEN_PATCH 2 /* awe_open_parm */ #define SNDRV_SFNT_CLOSE_PATCH 3 /* none */ /* 4 is obsolete */ #define SNDRV_SFNT_REPLACE_DATA 5 /* awe_sample_info (optarg=#channels)*/ #define SNDRV_SFNT_MAP_PRESET 6 /* awe_voice_map */ /* 7 is not used */ #define SNDRV_SFNT_PROBE_DATA 8 /* optarg=sample */ #define SNDRV_SFNT_REMOVE_INFO 9 /* optarg=(bank<<8)|instr */ short reserved; /* word alignment data */ /* the actual patch data begins after this */ }; /* * open patch */ #define SNDRV_SFNT_PATCH_NAME_LEN 32 struct soundfont_open_parm { unsigned short type; /* sample type */ #define SNDRV_SFNT_PAT_TYPE_MISC 0 #define SNDRV_SFNT_PAT_TYPE_GUS 6 #define SNDRV_SFNT_PAT_TYPE_MAP 7 #define SNDRV_SFNT_PAT_LOCKED 0x100 /* lock the samples */ #define SNDRV_SFNT_PAT_SHARED 0x200 /* sample is shared */ short reserved; char name[SNDRV_SFNT_PATCH_NAME_LEN]; }; /* * raw voice information record */ /* wave table envelope & effect parameters to control EMU8000 */ struct soundfont_voice_parm { unsigned short moddelay; /* modulation delay (0x8000) */ unsigned short modatkhld; /* modulation attack & hold time (0x7f7f) */ unsigned short moddcysus; /* modulation decay & sustain (0x7f7f) */ unsigned short modrelease; /* modulation release time (0x807f) */ short modkeyhold, modkeydecay; /* envelope change per key (not used) */ unsigned short voldelay; /* volume delay (0x8000) */ unsigned short volatkhld; /* volume attack & hold time (0x7f7f) */ unsigned short voldcysus; /* volume decay & sustain (0x7f7f) */ unsigned short volrelease; /* volume release time (0x807f) */ short volkeyhold, volkeydecay; /* envelope change per key (not used) */ unsigned short lfo1delay; /* LFO1 delay (0x8000) */ unsigned short lfo2delay; /* LFO2 delay (0x8000) */ unsigned short pefe; /* modulation pitch & cutoff (0x0000) */ unsigned short fmmod; /* LFO1 pitch & cutoff (0x0000) */ unsigned short tremfrq; /* LFO1 volume & freq (0x0000) */ unsigned short fm2frq2; /* LFO2 pitch & freq (0x0000) */ unsigned char cutoff; /* initial cutoff (0xff) */ unsigned char filterQ; /* initial filter Q [0-15] (0x0) */ unsigned char chorus; /* chorus send (0x00) */ unsigned char reverb; /* reverb send (0x00) */ unsigned short reserved[4]; /* not used */ }; /* wave table parameters: 92 bytes */ struct soundfont_voice_info { unsigned short sf_id; /* file id (should be zero) */ unsigned short sample; /* sample id */ int start, end; /* sample offset correction */ int loopstart, loopend; /* loop offset correction */ short rate_offset; /* sample rate pitch offset */ unsigned short mode; /* sample mode */ #define SNDRV_SFNT_MODE_ROMSOUND 0x8000 #define SNDRV_SFNT_MODE_STEREO 1 #define SNDRV_SFNT_MODE_LOOPING 2 #define SNDRV_SFNT_MODE_NORELEASE 4 /* obsolete */ #define SNDRV_SFNT_MODE_INIT_PARM 8 short root; /* midi root key */ short tune; /* pitch tuning (in cents) */ unsigned char low, high; /* key note range */ unsigned char vellow, velhigh; /* velocity range */ signed char fixkey, fixvel; /* fixed key, velocity */ signed char pan, fixpan; /* panning, fixed panning */ short exclusiveClass; /* exclusive class (0 = none) */ unsigned char amplitude; /* sample volume (127 max) */ unsigned char attenuation; /* attenuation (0.375dB) */ short scaleTuning; /* pitch scale tuning(%), normally 100 */ struct soundfont_voice_parm parm; /* voice envelope parameters */ unsigned short sample_mode; /* sample mode_flag (set by driver) */ }; /* instrument info header: 4 bytes */ struct soundfont_voice_rec_hdr { unsigned char bank; /* midi bank number */ unsigned char instr; /* midi preset number */ char nvoices; /* number of voices */ char write_mode; /* write mode; normally 0 */ #define SNDRV_SFNT_WR_APPEND 0 /* append anyway */ #define SNDRV_SFNT_WR_EXCLUSIVE 1 /* skip if already exists */ #define SNDRV_SFNT_WR_REPLACE 2 /* replace if already exists */ }; /* * sample wave information */ /* wave table sample header: 32 bytes */ struct soundfont_sample_info { unsigned short sf_id; /* file id (should be zero) */ unsigned short sample; /* sample id */ int start, end; /* start & end offset */ int loopstart, loopend; /* loop start & end offset */ int size; /* size (0 = ROM) */ short dummy; /* not used */ unsigned short mode_flags; /* mode flags */ #define SNDRV_SFNT_SAMPLE_8BITS 1 /* wave data is 8bits */ #define SNDRV_SFNT_SAMPLE_UNSIGNED 2 /* wave data is unsigned */ #define SNDRV_SFNT_SAMPLE_NO_BLANK 4 /* no blank loop is attached */ #define SNDRV_SFNT_SAMPLE_SINGLESHOT 8 /* single-shot w/o loop */ #define SNDRV_SFNT_SAMPLE_BIDIR_LOOP 16 /* bidirectional looping */ #define SNDRV_SFNT_SAMPLE_STEREO_LEFT 32 /* stereo left sound */ #define SNDRV_SFNT_SAMPLE_STEREO_RIGHT 64 /* stereo right sound */ #define SNDRV_SFNT_SAMPLE_REVERSE_LOOP 128 /* reverse looping */ unsigned int truesize; /* used memory size (set by driver) */ }; /* * voice preset mapping (aliasing) */ struct soundfont_voice_map { int map_bank, map_instr, map_key; /* key = -1 means all keys */ int src_bank, src_instr, src_key; }; /* * ioctls for hwdep */ #define SNDRV_EMUX_HWDEP_NAME "Emux WaveTable" #define SNDRV_EMUX_VERSION ((1 << 16) | (0 << 8) | 0) /* 1.0.0 */ struct snd_emux_misc_mode { int port; /* -1 = all */ int mode; int value; int value2; /* reserved */ }; #define SNDRV_EMUX_IOCTL_VERSION _IOR('H', 0x80, unsigned int) #define SNDRV_EMUX_IOCTL_LOAD_PATCH _IOWR('H', 0x81, struct soundfont_patch_info) #define SNDRV_EMUX_IOCTL_RESET_SAMPLES _IO('H', 0x82) #define SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES _IO('H', 0x83) #define SNDRV_EMUX_IOCTL_MEM_AVAIL _IOW('H', 0x84, int) #define SNDRV_EMUX_IOCTL_MISC_MODE _IOWR('H', 0x84, struct snd_emux_misc_mode) #endif /* __SOUND_SFNT_INFO_H */ sound/asound_fm.h000064400000007065152640040150010025 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ #ifndef __SOUND_ASOUND_FM_H #define __SOUND_ASOUND_FM_H /* * Advanced Linux Sound Architecture - ALSA * * Interface file between ALSA driver & user space * Copyright (c) 1994-98 by Jaroslav Kysela , * 4Front Technologies * * Direct FM control */ #define SNDRV_DM_FM_MODE_OPL2 0x00 #define SNDRV_DM_FM_MODE_OPL3 0x01 struct snd_dm_fm_info { unsigned char fm_mode; /* OPL mode, see SNDRV_DM_FM_MODE_XXX */ unsigned char rhythm; /* percussion mode flag */ }; /* * Data structure composing an FM "note" or sound event. */ struct snd_dm_fm_voice { unsigned char op; /* operator cell (0 or 1) */ unsigned char voice; /* FM voice (0 to 17) */ unsigned char am; /* amplitude modulation */ unsigned char vibrato; /* vibrato effect */ unsigned char do_sustain; /* sustain phase */ unsigned char kbd_scale; /* keyboard scaling */ unsigned char harmonic; /* 4 bits: harmonic and multiplier */ unsigned char scale_level; /* 2 bits: decrease output freq rises */ unsigned char volume; /* 6 bits: volume */ unsigned char attack; /* 4 bits: attack rate */ unsigned char decay; /* 4 bits: decay rate */ unsigned char sustain; /* 4 bits: sustain level */ unsigned char release; /* 4 bits: release rate */ unsigned char feedback; /* 3 bits: feedback for op0 */ unsigned char connection; /* 0 for serial, 1 for parallel */ unsigned char left; /* stereo left */ unsigned char right; /* stereo right */ unsigned char waveform; /* 3 bits: waveform shape */ }; /* * This describes an FM note by its voice, octave, frequency number (10bit) * and key on/off. */ struct snd_dm_fm_note { unsigned char voice; /* 0-17 voice channel */ unsigned char octave; /* 3 bits: what octave to play */ unsigned int fnum; /* 10 bits: frequency number */ unsigned char key_on; /* set for active, clear for silent */ }; /* * FM parameters that apply globally to all voices, and thus are not "notes" */ struct snd_dm_fm_params { unsigned char am_depth; /* amplitude modulation depth (1=hi) */ unsigned char vib_depth; /* vibrato depth (1=hi) */ unsigned char kbd_split; /* keyboard split */ unsigned char rhythm; /* percussion mode select */ /* This block is the percussion instrument data */ unsigned char bass; unsigned char snare; unsigned char tomtom; unsigned char cymbal; unsigned char hihat; }; /* * FM mode ioctl settings */ #define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, struct snd_dm_fm_info) #define SNDRV_DM_FM_IOCTL_RESET _IO ('H', 0x21) #define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, struct snd_dm_fm_note) #define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, struct snd_dm_fm_voice) #define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, struct snd_dm_fm_params) #define SNDRV_DM_FM_IOCTL_SET_MODE _IOW('H', 0x25, int) /* for OPL3 only */ #define SNDRV_DM_FM_IOCTL_SET_CONNECTION _IOW('H', 0x26, int) /* SBI patch management */ #define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES _IO ('H', 0x40) #define SNDRV_DM_FM_OSS_IOCTL_RESET 0x20 #define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE 0x21 #define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE 0x22 #define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS 0x23 #define SNDRV_DM_FM_OSS_IOCTL_SET_MODE 0x24 #define SNDRV_DM_FM_OSS_IOCTL_SET_OPL 0x25 /* * Patch Record - fixed size for write */ #define FM_KEY_SBI "SBI\032" #define FM_KEY_2OP "2OP\032" #define FM_KEY_4OP "4OP\032" struct sbi_patch { unsigned char prog; unsigned char bank; char key[4]; char name[25]; char extension[7]; unsigned char data[32]; }; #endif /* __SOUND_ASOUND_FM_H */ sound/asoc.h000064400000053726152640040150007004 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM * * Copyright (C) 2012 Texas Instruments Inc. * Copyright (C) 2015 Intel Corporation. * * Simple file API to load FW that includes mixers, coefficients, DAPM graphs, * algorithms, equalisers, DAIs, widgets etc. */ #ifndef __LINUX_UAPI_SND_ASOC_H #define __LINUX_UAPI_SND_ASOC_H #include #include /* * Maximum number of channels topology kcontrol can represent. */ #define SND_SOC_TPLG_MAX_CHAN 8 /* * Maximum number of PCM formats capability */ #define SND_SOC_TPLG_MAX_FORMATS 16 /* * Maximum number of PCM stream configs */ #define SND_SOC_TPLG_STREAM_CONFIG_MAX 8 /* * Maximum number of physical link's hardware configs */ #define SND_SOC_TPLG_HW_CONFIG_MAX 8 /* individual kcontrol info types - can be mixed with other types */ #define SND_SOC_TPLG_CTL_VOLSW 1 #define SND_SOC_TPLG_CTL_VOLSW_SX 2 #define SND_SOC_TPLG_CTL_VOLSW_XR_SX 3 #define SND_SOC_TPLG_CTL_ENUM 4 #define SND_SOC_TPLG_CTL_BYTES 5 #define SND_SOC_TPLG_CTL_ENUM_VALUE 6 #define SND_SOC_TPLG_CTL_RANGE 7 #define SND_SOC_TPLG_CTL_STROBE 8 /* individual widget kcontrol info types - can be mixed with other types */ #define SND_SOC_TPLG_DAPM_CTL_VOLSW 64 #define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE 65 #define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT 66 #define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE 67 #define SND_SOC_TPLG_DAPM_CTL_PIN 68 /* DAPM widget types - add new items to the end */ #define SND_SOC_TPLG_DAPM_INPUT 0 #define SND_SOC_TPLG_DAPM_OUTPUT 1 #define SND_SOC_TPLG_DAPM_MUX 2 #define SND_SOC_TPLG_DAPM_MIXER 3 #define SND_SOC_TPLG_DAPM_PGA 4 #define SND_SOC_TPLG_DAPM_OUT_DRV 5 #define SND_SOC_TPLG_DAPM_ADC 6 #define SND_SOC_TPLG_DAPM_DAC 7 #define SND_SOC_TPLG_DAPM_SWITCH 8 #define SND_SOC_TPLG_DAPM_PRE 9 #define SND_SOC_TPLG_DAPM_POST 10 #define SND_SOC_TPLG_DAPM_AIF_IN 11 #define SND_SOC_TPLG_DAPM_AIF_OUT 12 #define SND_SOC_TPLG_DAPM_DAI_IN 13 #define SND_SOC_TPLG_DAPM_DAI_OUT 14 #define SND_SOC_TPLG_DAPM_DAI_LINK 15 #define SND_SOC_TPLG_DAPM_BUFFER 16 #define SND_SOC_TPLG_DAPM_SCHEDULER 17 #define SND_SOC_TPLG_DAPM_EFFECT 18 #define SND_SOC_TPLG_DAPM_SIGGEN 19 #define SND_SOC_TPLG_DAPM_SRC 20 #define SND_SOC_TPLG_DAPM_ASRC 21 #define SND_SOC_TPLG_DAPM_ENCODER 22 #define SND_SOC_TPLG_DAPM_DECODER 23 #define SND_SOC_TPLG_DAPM_LAST SND_SOC_TPLG_DAPM_DECODER /* Header magic number and string sizes */ #define SND_SOC_TPLG_MAGIC 0x41536F43 /* ASoC */ /* string sizes */ #define SND_SOC_TPLG_NUM_TEXTS 16 /* ABI version */ #define SND_SOC_TPLG_ABI_VERSION 0x5 /* current version */ #define SND_SOC_TPLG_ABI_VERSION_MIN 0x4 /* oldest version supported */ /* Max size of TLV data */ #define SND_SOC_TPLG_TLV_SIZE 32 /* * File and Block header data types. * Add new generic and vendor types to end of list. * Generic types are handled by the core whilst vendors types are passed * to the component drivers for handling. */ #define SND_SOC_TPLG_TYPE_MIXER 1 #define SND_SOC_TPLG_TYPE_BYTES 2 #define SND_SOC_TPLG_TYPE_ENUM 3 #define SND_SOC_TPLG_TYPE_DAPM_GRAPH 4 #define SND_SOC_TPLG_TYPE_DAPM_WIDGET 5 #define SND_SOC_TPLG_TYPE_DAI_LINK 6 #define SND_SOC_TPLG_TYPE_PCM 7 #define SND_SOC_TPLG_TYPE_MANIFEST 8 #define SND_SOC_TPLG_TYPE_CODEC_LINK 9 #define SND_SOC_TPLG_TYPE_BACKEND_LINK 10 #define SND_SOC_TPLG_TYPE_PDATA 11 #define SND_SOC_TPLG_TYPE_DAI 12 #define SND_SOC_TPLG_TYPE_MAX SND_SOC_TPLG_TYPE_DAI /* vendor block IDs - please add new vendor types to end */ #define SND_SOC_TPLG_TYPE_VENDOR_FW 1000 #define SND_SOC_TPLG_TYPE_VENDOR_CONFIG 1001 #define SND_SOC_TPLG_TYPE_VENDOR_COEFF 1002 #define SND_SOC_TPLG_TYPEVENDOR_CODEC 1003 #define SND_SOC_TPLG_STREAM_PLAYBACK 0 #define SND_SOC_TPLG_STREAM_CAPTURE 1 /* vendor tuple types */ #define SND_SOC_TPLG_TUPLE_TYPE_UUID 0 #define SND_SOC_TPLG_TUPLE_TYPE_STRING 1 #define SND_SOC_TPLG_TUPLE_TYPE_BOOL 2 #define SND_SOC_TPLG_TUPLE_TYPE_BYTE 3 #define SND_SOC_TPLG_TUPLE_TYPE_WORD 4 #define SND_SOC_TPLG_TUPLE_TYPE_SHORT 5 /* DAI flags */ #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES (1 << 0) #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) /* DAI clock gating */ #define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED 0 #define SND_SOC_TPLG_DAI_CLK_GATE_GATED 1 #define SND_SOC_TPLG_DAI_CLK_GATE_CONT 2 /* DAI mclk_direction */ #define SND_SOC_TPLG_MCLK_CO 0 /* for codec, mclk is output */ #define SND_SOC_TPLG_MCLK_CI 1 /* for codec, mclk is input */ /* DAI physical PCM data formats. * Add new formats to the end of the list. */ #define SND_SOC_DAI_FORMAT_I2S 1 /* I2S mode */ #define SND_SOC_DAI_FORMAT_RIGHT_J 2 /* Right Justified mode */ #define SND_SOC_DAI_FORMAT_LEFT_J 3 /* Left Justified mode */ #define SND_SOC_DAI_FORMAT_DSP_A 4 /* L data MSB after FRM LRC */ #define SND_SOC_DAI_FORMAT_DSP_B 5 /* L data MSB during FRM LRC */ #define SND_SOC_DAI_FORMAT_AC97 6 /* AC97 */ #define SND_SOC_DAI_FORMAT_PDM 7 /* Pulse density modulation */ /* left and right justified also known as MSB and LSB respectively */ #define SND_SOC_DAI_FORMAT_MSB SND_SOC_DAI_FORMAT_LEFT_J #define SND_SOC_DAI_FORMAT_LSB SND_SOC_DAI_FORMAT_RIGHT_J /* DAI link flags */ #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES (1 << 0) #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) #define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP (1 << 3) /* DAI topology BCLK parameter * For the backwards capability, by default codec is bclk provider */ #define SND_SOC_TPLG_BCLK_CP 0 /* codec is bclk provider */ #define SND_SOC_TPLG_BCLK_CC 1 /* codec is bclk consumer */ /* keep previous definitions for compatibility */ #define SND_SOC_TPLG_BCLK_CM SND_SOC_TPLG_BCLK_CP #define SND_SOC_TPLG_BCLK_CS SND_SOC_TPLG_BCLK_CC /* DAI topology FSYNC parameter * For the backwards capability, by default codec is fsync provider */ #define SND_SOC_TPLG_FSYNC_CP 0 /* codec is fsync provider */ #define SND_SOC_TPLG_FSYNC_CC 1 /* codec is fsync consumer */ /* keep previous definitions for compatibility */ #define SND_SOC_TPLG_FSYNC_CM SND_SOC_TPLG_FSYNC_CP #define SND_SOC_TPLG_FSYNC_CS SND_SOC_TPLG_FSYNC_CC /* * Block Header. * This header precedes all object and object arrays below. */ struct snd_soc_tplg_hdr { __le32 magic; /* magic number */ __le32 abi; /* ABI version */ __le32 version; /* optional vendor specific version details */ __le32 type; /* SND_SOC_TPLG_TYPE_ */ __le32 size; /* size of this structure */ __le32 vendor_type; /* optional vendor specific type info */ __le32 payload_size; /* data bytes, excluding this header */ __le32 index; /* identifier for block */ __le32 count; /* number of elements in block */ } __attribute__((packed)); /* vendor tuple for uuid */ struct snd_soc_tplg_vendor_uuid_elem { __le32 token; char uuid[16]; } __attribute__((packed)); /* vendor tuple for a bool/byte/short/word value */ struct snd_soc_tplg_vendor_value_elem { __le32 token; __le32 value; } __attribute__((packed)); /* vendor tuple for string */ struct snd_soc_tplg_vendor_string_elem { __le32 token; char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; } __attribute__((packed)); struct snd_soc_tplg_vendor_array { __le32 size; /* size in bytes of the array, including all elements */ __le32 type; /* SND_SOC_TPLG_TUPLE_TYPE_ */ __le32 num_elems; /* number of elements in array */ union { __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_uuid_elem, uuid); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_value_elem, value); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_string_elem, string); }; } __attribute__((packed)); /* * Private data. * All topology objects may have private data that can be used by the driver or * firmware. Core will ignore this data. */ struct snd_soc_tplg_private { __le32 size; /* in bytes of private data */ union { __DECLARE_FLEX_ARRAY(char, data); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_array, array); }; } __attribute__((packed)); /* * Kcontrol TLV data. */ struct snd_soc_tplg_tlv_dbscale { __le32 min; __le32 step; __le32 mute; } __attribute__((packed)); struct snd_soc_tplg_ctl_tlv { __le32 size; /* in bytes of this structure */ __le32 type; /* SNDRV_CTL_TLVT_*, type of TLV */ union { __le32 data[SND_SOC_TPLG_TLV_SIZE]; struct snd_soc_tplg_tlv_dbscale scale; }; } __attribute__((packed)); /* * Kcontrol channel data */ struct snd_soc_tplg_channel { __le32 size; /* in bytes of this structure */ __le32 reg; __le32 shift; __le32 id; /* ID maps to Left, Right, LFE etc */ } __attribute__((packed)); /* * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops * Kcontrol ops need get/put/info. * Bytes ext ops need get/put. */ struct snd_soc_tplg_io_ops { __le32 get; __le32 put; __le32 info; } __attribute__((packed)); /* * kcontrol header */ struct snd_soc_tplg_ctl_hdr { __le32 size; /* in bytes of this structure */ __le32 type; char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 access; struct snd_soc_tplg_io_ops ops; struct snd_soc_tplg_ctl_tlv tlv; } __attribute__((packed)); /* * Stream Capabilities */ struct snd_soc_tplg_stream_caps { __le32 size; /* in bytes of this structure */ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ __le32 rate_min; /* min rate */ __le32 rate_max; /* max rate */ __le32 channels_min; /* min channels */ __le32 channels_max; /* max channels */ __le32 periods_min; /* min number of periods */ __le32 periods_max; /* max number of periods */ __le32 period_size_min; /* min period size bytes */ __le32 period_size_max; /* max period size bytes */ __le32 buffer_size_min; /* min buffer size bytes */ __le32 buffer_size_max; /* max buffer size bytes */ __le32 sig_bits; /* number of bits of content */ } __attribute__((packed)); /* * FE or BE Stream configuration supported by SW/FW */ struct snd_soc_tplg_stream { __le32 size; /* in bytes of this structure */ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Name of the stream */ __le64 format; /* SNDRV_PCM_FMTBIT_* */ __le32 rate; /* SNDRV_PCM_RATE_* */ __le32 period_bytes; /* size of period in bytes */ __le32 buffer_bytes; /* size of buffer in bytes */ __le32 channels; /* channels */ } __attribute__((packed)); /* * Describes a physical link's runtime supported hardware config, * i.e. hardware audio formats. */ struct snd_soc_tplg_hw_config { __le32 size; /* in bytes of this structure */ __le32 id; /* unique ID - - used to match */ __le32 fmt; /* SND_SOC_DAI_FORMAT_ format value */ __u8 clock_gated; /* SND_SOC_TPLG_DAI_CLK_GATE_ value */ __u8 invert_bclk; /* 1 for inverted BCLK, 0 for normal */ __u8 invert_fsync; /* 1 for inverted frame clock, 0 for normal */ __u8 bclk_provider; /* SND_SOC_TPLG_BCLK_ value */ __u8 fsync_provider; /* SND_SOC_TPLG_FSYNC_ value */ __u8 mclk_direction; /* SND_SOC_TPLG_MCLK_ value */ __le16 reserved; /* for 32bit alignment */ __le32 mclk_rate; /* MCLK or SYSCLK freqency in Hz */ __le32 bclk_rate; /* BCLK freqency in Hz */ __le32 fsync_rate; /* frame clock in Hz */ __le32 tdm_slots; /* number of TDM slots in use */ __le32 tdm_slot_width; /* width in bits for each slot */ __le32 tx_slots; /* bit mask for active Tx slots */ __le32 rx_slots; /* bit mask for active Rx slots */ __le32 tx_channels; /* number of Tx channels */ __le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ __le32 rx_channels; /* number of Rx channels */ __le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ } __attribute__((packed)); /* * Manifest. List totals for each payload type. Not used in parsing, but will * be passed to the component driver before any other objects in order for any * global component resource allocations. * * File block representation for manifest :- * +-----------------------------------+----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+----+ * | struct snd_soc_tplg_manifest | 1 | * +-----------------------------------+----+ */ struct snd_soc_tplg_manifest { __le32 size; /* in bytes of this structure */ __le32 control_elems; /* number of control elements */ __le32 widget_elems; /* number of widget elements */ __le32 graph_elems; /* number of graph elements */ __le32 pcm_elems; /* number of PCM elements */ __le32 dai_link_elems; /* number of DAI link elements */ __le32 dai_elems; /* number of physical DAI elements */ __le32 reserved[20]; /* reserved for new ABI element types */ struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Mixer kcontrol. * * File block representation for mixer kcontrol :- * +-----------------------------------+----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+----+ * | struct snd_soc_tplg_mixer_control | N | * +-----------------------------------+----+ */ struct snd_soc_tplg_mixer_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; /* in bytes of this structure */ __le32 min; __le32 max; __le32 platform_max; __le32 invert; __le32 num_channels; struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Enumerated kcontrol * * File block representation for enum kcontrol :- * +-----------------------------------+----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+----+ * | struct snd_soc_tplg_enum_control | N | * +-----------------------------------+----+ */ struct snd_soc_tplg_enum_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; /* in bytes of this structure */ __le32 num_channels; struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; __le32 items; __le32 mask; __le32 count; char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4]; struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Bytes kcontrol * * File block representation for bytes kcontrol :- * +-----------------------------------+----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+----+ * | struct snd_soc_tplg_bytes_control | N | * +-----------------------------------+----+ */ struct snd_soc_tplg_bytes_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; /* in bytes of this structure */ __le32 max; __le32 mask; __le32 base; __le32 num_regs; struct snd_soc_tplg_io_ops ext_ops; struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * DAPM Graph Element * * File block representation for DAPM graph elements :- * +-------------------------------------+----+ * | struct snd_soc_tplg_hdr | 1 | * +-------------------------------------+----+ * | struct snd_soc_tplg_dapm_graph_elem | N | * +-------------------------------------+----+ */ struct snd_soc_tplg_dapm_graph_elem { char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; } __attribute__((packed)); /* * DAPM Widget. * * File block representation for DAPM widget :- * +-------------------------------------+-----+ * | struct snd_soc_tplg_hdr | 1 | * +-------------------------------------+-----+ * | struct snd_soc_tplg_dapm_widget | N | * +-------------------------------------+-----+ * | struct snd_soc_tplg_enum_control | 0|1 | * | struct snd_soc_tplg_mixer_control | 0|N | * +-------------------------------------+-----+ * * Optional enum or mixer control can be appended to the end of each widget * in the block. */ struct snd_soc_tplg_dapm_widget { __le32 size; /* in bytes of this structure */ __le32 id; /* SND_SOC_DAPM_CTL */ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 reg; /* negative reg = no direct dapm */ __le32 shift; /* bits to shift */ __le32 mask; /* non-shifted mask */ __le32 subseq; /* sort within widget type */ __le32 invert; /* invert the power bit */ __le32 ignore_suspend; /* kept enabled over suspend */ __le16 event_flags; __le16 event_type; __le32 num_kcontrols; struct snd_soc_tplg_private priv; /* * kcontrols that relate to this widget * follow here after widget private data */ } __attribute__((packed)); /* * Describes SW/FW specific features of PCM (FE DAI & DAI link). * * File block representation for PCM :- * +-----------------------------------+-----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+-----+ * | struct snd_soc_tplg_pcm | N | * +-----------------------------------+-----+ */ struct snd_soc_tplg_pcm { __le32 size; /* in bytes of this structure */ char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 pcm_id; /* unique ID - used to match with DAI link */ __le32 dai_id; /* unique ID - used to match */ __le32 playback; /* supports playback mode */ __le32 capture; /* supports capture mode */ __le32 compress; /* 1 = compressed; 0 = PCM */ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ __le32 num_streams; /* number of streams */ struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ __le32 flag_mask; /* bitmask of flags to configure */ __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Describes the physical link runtime supported configs or params * * File block representation for physical link config :- * +-----------------------------------+-----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+-----+ * | struct snd_soc_tplg_link_config | N | * +-----------------------------------+-----+ */ struct snd_soc_tplg_link_config { __le32 size; /* in bytes of this structure */ __le32 id; /* unique ID - used to match */ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ __le32 num_streams; /* number of streams */ struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */ __le32 num_hw_configs; /* number of hw configs */ __le32 default_hw_config_id; /* default hw config ID for init */ __le32 flag_mask; /* bitmask of flags to configure */ __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Describes SW/FW specific features of physical DAI. * It can be used to configure backend DAIs for DPCM. * * File block representation for physical DAI :- * +-----------------------------------+-----+ * | struct snd_soc_tplg_hdr | 1 | * +-----------------------------------+-----+ * | struct snd_soc_tplg_dai | N | * +-----------------------------------+-----+ */ struct snd_soc_tplg_dai { __le32 size; /* in bytes of this structure */ char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ __le32 dai_id; /* unique ID - used to match */ __le32 playback; /* supports playback mode */ __le32 capture; /* supports capture mode */ struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ __le32 flag_mask; /* bitmask of flags to configure */ __le32 flags; /* SND_SOC_TPLG_DAI_FLGBIT_* */ struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Old version of ABI structs, supported for backward compatibility. */ /* Manifest v4 */ struct snd_soc_tplg_manifest_v4 { __le32 size; /* in bytes of this structure */ __le32 control_elems; /* number of control elements */ __le32 widget_elems; /* number of widget elements */ __le32 graph_elems; /* number of graph elements */ __le32 pcm_elems; /* number of PCM elements */ __le32 dai_link_elems; /* number of DAI link elements */ struct snd_soc_tplg_private priv; } __attribute__((packed)); /* Stream Capabilities v4 */ struct snd_soc_tplg_stream_caps_v4 { __le32 size; /* in bytes of this structure */ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ __le32 rate_min; /* min rate */ __le32 rate_max; /* max rate */ __le32 channels_min; /* min channels */ __le32 channels_max; /* max channels */ __le32 periods_min; /* min number of periods */ __le32 periods_max; /* max number of periods */ __le32 period_size_min; /* min period size bytes */ __le32 period_size_max; /* max period size bytes */ __le32 buffer_size_min; /* min buffer size bytes */ __le32 buffer_size_max; /* max buffer size bytes */ } __attribute__((packed)); /* PCM v4 */ struct snd_soc_tplg_pcm_v4 { __le32 size; /* in bytes of this structure */ char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 pcm_id; /* unique ID - used to match with DAI link */ __le32 dai_id; /* unique ID - used to match */ __le32 playback; /* supports playback mode */ __le32 capture; /* supports capture mode */ __le32 compress; /* 1 = compressed; 0 = PCM */ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ __le32 num_streams; /* number of streams */ struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */ } __attribute__((packed)); /* Physical link config v4 */ struct snd_soc_tplg_link_config_v4 { __le32 size; /* in bytes of this structure */ __le32 id; /* unique ID - used to match */ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ __le32 num_streams; /* number of streams */ } __attribute__((packed)); #endif sound/hdspm.h000064400000010606152640040150007160 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ #ifndef __SOUND_HDSPM_H #define __SOUND_HDSPM_H /* * Copyright (C) 2003 Winfried Ritsch (IEM) * based on hdsp.h from Thomas Charbonnel (thomas@undata.org) */ #ifdef __linux__ #include #endif /* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */ #define HDSPM_MAX_CHANNELS 64 enum hdspm_io_type { MADI, MADIface, AIO, AES32, RayDAT }; enum hdspm_speed { ss, ds, qs }; /* -------------------- IOCTL Peak/RMS Meters -------------------- */ struct hdspm_peak_rms { __u32 input_peaks[64]; __u32 playback_peaks[64]; __u32 output_peaks[64]; __u64 input_rms[64]; __u64 playback_rms[64]; __u64 output_rms[64]; __u8 speed; /* enum {ss, ds, qs} */ int status2; }; #define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \ _IOR('H', 0x42, struct hdspm_peak_rms) /* ------------ CONFIG block IOCTL ---------------------- */ struct hdspm_config { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char madi_sync_check; unsigned int system_sample_rate; unsigned int autosync_sample_rate; unsigned char system_clock_mode; unsigned char clock_source; unsigned char autosync_ref; unsigned char line_out; unsigned int passthru; unsigned int analog_out; }; #define SNDRV_HDSPM_IOCTL_GET_CONFIG \ _IOR('H', 0x41, struct hdspm_config) /* * If there's a TCO (TimeCode Option) board installed, * there are further options and status data available. * The hdspm_ltc structure contains the current SMPTE * timecode and some status information and can be * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the * hdspm_status struct. */ enum hdspm_ltc_format { format_invalid, fps_24, fps_25, fps_2997, fps_30 }; enum hdspm_ltc_frame { frame_invalid, drop_frame, full_frame }; enum hdspm_ltc_input_format { ntsc, pal, no_video }; struct hdspm_ltc { unsigned int ltc; enum hdspm_ltc_format format; enum hdspm_ltc_frame frame; enum hdspm_ltc_input_format input_format; }; #define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc) /* * The status data reflects the device's current state * as determined by the card's configuration and * connection status. */ enum hdspm_sync { hdspm_sync_no_lock = 0, hdspm_sync_lock = 1, hdspm_sync_sync = 2 }; enum hdspm_madi_input { hdspm_input_optical = 0, hdspm_input_coax = 1 }; enum hdspm_madi_channel_format { hdspm_format_ch_64 = 0, hdspm_format_ch_56 = 1 }; enum hdspm_madi_frame_format { hdspm_frame_48 = 0, hdspm_frame_96 = 1 }; enum hdspm_syncsource { syncsource_wc = 0, syncsource_madi = 1, syncsource_tco = 2, syncsource_sync = 3, syncsource_none = 4 }; struct hdspm_status { __u8 card_type; /* enum hdspm_io_type */ enum hdspm_syncsource autosync_source; __u64 card_clock; __u32 master_period; union { struct { __u8 sync_wc; /* enum hdspm_sync */ __u8 sync_madi; /* enum hdspm_sync */ __u8 sync_tco; /* enum hdspm_sync */ __u8 sync_in; /* enum hdspm_sync */ __u8 madi_input; /* enum hdspm_madi_input */ __u8 channel_format; /* enum hdspm_madi_channel_format */ __u8 frame_format; /* enum hdspm_madi_frame_format */ } madi; } card_specific; }; #define SNDRV_HDSPM_IOCTL_GET_STATUS \ _IOR('H', 0x47, struct hdspm_status) /* * Get information about the card and its add-ons. */ #define HDSPM_ADDON_TCO 1 struct hdspm_version { __u8 card_type; /* enum hdspm_io_type */ char cardname[20]; unsigned int serial; unsigned short firmware_rev; int addons; }; #define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version) /* ------------- get Matrix Mixer IOCTL --------------- */ /* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte = * 32768 Bytes */ /* organisation is 64 channelfader in a continuous memory block */ /* equivalent to hardware definition, maybe for future feature of mmap of * them */ /* each of 64 outputs has 64 infader and 64 outfader: Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */ #define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS struct hdspm_channelfader { unsigned int in[HDSPM_MIXER_CHANNELS]; unsigned int pb[HDSPM_MIXER_CHANNELS]; }; struct hdspm_mixer { struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS]; }; struct hdspm_mixer_ioctl { struct hdspm_mixer *mixer; }; /* use indirect access due to the limit of ioctl bit size */ #define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) #endif sound/snd_sst_tokens.h000064400000026752152640040150011116 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * snd_sst_tokens.h - Intel SST tokens definition * * Copyright (C) 2016 Intel Corp * Author: Shreyas NC */ #ifndef __SND_SST_TOKENS_H__ #define __SND_SST_TOKENS_H__ /** * %SKL_TKN_UUID: Module UUID * * %SKL_TKN_U8_BLOCK_TYPE: Type of the private data block.Can be: * tuples, bytes, short and words * * %SKL_TKN_U8_IN_PIN_TYPE: Input pin type, * homogenous=0, heterogenous=1 * * %SKL_TKN_U8_OUT_PIN_TYPE: Output pin type, * homogenous=0, heterogenous=1 * %SKL_TKN_U8_DYN_IN_PIN: Configure Input pin dynamically * if true * * %SKL_TKN_U8_DYN_OUT_PIN: Configure Output pin dynamically * if true * * %SKL_TKN_U8_IN_QUEUE_COUNT: Store the number of Input pins * * %SKL_TKN_U8_OUT_QUEUE_COUNT: Store the number of Output pins * * %SKL_TKN_U8_TIME_SLOT: TDM slot number * * %SKL_TKN_U8_CORE_ID: Stores module affinity value.Can take * the values: * SKL_AFFINITY_CORE_0 = 0, * SKL_AFFINITY_CORE_1, * SKL_AFFINITY_CORE_MAX * * %SKL_TKN_U8_MOD_TYPE: Module type value. * * %SKL_TKN_U8_CONN_TYPE: Module connection type can be a FE, * BE or NONE as defined : * SKL_PIPE_CONN_TYPE_NONE = 0, * SKL_PIPE_CONN_TYPE_FE = 1 (HOST_DMA) * SKL_PIPE_CONN_TYPE_BE = 2 (LINK_DMA) * * %SKL_TKN_U8_DEV_TYPE: Type of device to which the module is * connected * Can take the values: * SKL_DEVICE_BT = 0x0, * SKL_DEVICE_DMIC = 0x1, * SKL_DEVICE_I2S = 0x2, * SKL_DEVICE_SLIMBUS = 0x3, * SKL_DEVICE_HDALINK = 0x4, * SKL_DEVICE_HDAHOST = 0x5, * SKL_DEVICE_NONE * * %SKL_TKN_U8_HW_CONN_TYPE: Connection type of the HW to which the * module is connected * SKL_CONN_NONE = 0, * SKL_CONN_SOURCE = 1, * SKL_CONN_SINK = 2 * * %SKL_TKN_U16_PIN_INST_ID: Stores the pin instance id * * %SKL_TKN_U16_MOD_INST_ID: Stores the mdule instance id * * %SKL_TKN_U32_MAX_MCPS: Module max mcps value * * %SKL_TKN_U32_MEM_PAGES: Module resource pages * * %SKL_TKN_U32_OBS: Stores Output Buffer size * * %SKL_TKN_U32_IBS: Stores input buffer size * * %SKL_TKN_U32_VBUS_ID: Module VBUS_ID. PDM=0, SSP0=0, * SSP1=1,SSP2=2, * SSP3=3, SSP4=4, * SSP5=5, SSP6=6,INVALID * * %SKL_TKN_U32_PARAMS_FIXUP: Module Params fixup mask * %SKL_TKN_U32_CONVERTER: Module params converter mask * %SKL_TKN_U32_PIPE_ID: Stores the pipe id * * %SKL_TKN_U32_PIPE_CONN_TYPE: Type of the token to which the pipe is * connected to. It can be * SKL_PIPE_CONN_TYPE_NONE = 0, * SKL_PIPE_CONN_TYPE_FE = 1 (HOST_DMA), * SKL_PIPE_CONN_TYPE_BE = 2 (LINK_DMA), * * %SKL_TKN_U32_PIPE_PRIORITY: Pipe priority value * %SKL_TKN_U32_PIPE_MEM_PGS: Pipe resource pages * * %SKL_TKN_U32_DIR_PIN_COUNT: Value for the direction to set input/output * formats and the pin count. * The first 4 bits have the direction * value and the next 4 have * the pin count value. * SKL_DIR_IN = 0, SKL_DIR_OUT = 1. * The input and output formats * share the same set of tokens * with the distinction between input * and output made by reading direction * token. * * %SKL_TKN_U32_FMT_CH: Supported channel count * * %SKL_TKN_U32_FMT_FREQ: Supported frequency/sample rate * * %SKL_TKN_U32_FMT_BIT_DEPTH: Supported container size * * %SKL_TKN_U32_FMT_SAMPLE_SIZE:Number of samples in the container * * %SKL_TKN_U32_FMT_CH_CONFIG: Supported channel configurations for the * input/output. * * %SKL_TKN_U32_FMT_INTERLEAVE: Interleaving style which can be per * channel or per sample. The values can be : * SKL_INTERLEAVING_PER_CHANNEL = 0, * SKL_INTERLEAVING_PER_SAMPLE = 1, * * %SKL_TKN_U32_FMT_SAMPLE_TYPE: * Specifies the sample type. Can take the * values: SKL_SAMPLE_TYPE_INT_MSB = 0, * SKL_SAMPLE_TYPE_INT_LSB = 1, * SKL_SAMPLE_TYPE_INT_SIGNED = 2, * SKL_SAMPLE_TYPE_INT_UNSIGNED = 3, * SKL_SAMPLE_TYPE_FLOAT = 4 * * %SKL_TKN_U32_CH_MAP: Channel map values * %SKL_TKN_U32_MOD_SET_PARAMS: It can take these values: * SKL_PARAM_DEFAULT, SKL_PARAM_INIT, * SKL_PARAM_SET, SKL_PARAM_BIND * * %SKL_TKN_U32_MOD_PARAM_ID: ID of the module params * * %SKL_TKN_U32_CAPS_SET_PARAMS: * Set params value * * %SKL_TKN_U32_CAPS_PARAMS_ID: Params ID * * %SKL_TKN_U32_CAPS_SIZE: Caps size * * %SKL_TKN_U32_PROC_DOMAIN: Specify processing domain * * %SKL_TKN_U32_LIB_COUNT: Specifies the number of libraries * * %SKL_TKN_STR_LIB_NAME: Specifies the library name * * %SKL_TKN_U32_PMODE: Specifies the power mode for pipe * * %SKL_TKL_U32_D0I3_CAPS: Specifies the D0i3 capability for module * * %SKL_TKN_U32_DMA_BUF_SIZE: DMA buffer size in millisec * * %SKL_TKN_U32_PIPE_DIR: Specifies pipe direction. Can be * playback/capture. * * %SKL_TKN_U32_NUM_CONFIGS: Number of pipe configs * * %SKL_TKN_U32_PATH_MEM_PGS: Size of memory (in pages) required for pipeline * and its data * * %SKL_TKN_U32_PIPE_CONFIG_ID: Config id for the modules in the pipe * and PCM params supported by that pipe * config. This is used as index to fill * up the pipe config and module config * structure. * * %SKL_TKN_U32_CFG_FREQ: * %SKL_TKN_U8_CFG_CHAN: * %SKL_TKN_U8_CFG_BPS: PCM params (freq, channels, bits per sample) * supported for each of the pipe configs. * * %SKL_TKN_CFG_MOD_RES_ID: Module's resource index for each of the * pipe config * * %SKL_TKN_CFG_MOD_FMT_ID: Module's interface index for each of the * pipe config * * %SKL_TKN_U8_NUM_MOD: Number of modules in the manifest * * %SKL_TKN_MM_U8_MOD_IDX: Current index of the module in the manifest * * %SKL_TKN_MM_U8_NUM_RES: Number of resources for the module * * %SKL_TKN_MM_U8_NUM_INTF: Number of interfaces for the module * * %SKL_TKN_MM_U32_RES_ID: Resource index for the resource info to * be filled into. * A module can support multiple resource * configuration and is represnted as a * resource table. This index is used to * fill information into appropriate index. * * %SKL_TKN_MM_U32_CPS: DSP cycles per second * * %SKL_TKN_MM_U32_DMA_SIZE: Allocated buffer size for gateway DMA * * %SKL_TKN_MM_U32_CPC: DSP cycles allocated per frame * * %SKL_TKN_MM_U32_RES_PIN_ID: Resource pin index in the module * * %SKL_TKN_MM_U32_INTF_PIN_ID: Interface index in the module * * %SKL_TKN_MM_U32_PIN_BUF: Buffer size of the module pin * * %SKL_TKN_MM_U32_FMT_ID: Format index for each of the interface/ * format information to be filled into. * * %SKL_TKN_MM_U32_NUM_IN_FMT: Number of input formats * %SKL_TKN_MM_U32_NUM_OUT_FMT: Number of output formats * * %SKL_TKN_U32_ASTATE_IDX: Table Index for the A-State entry to be filled * with kcps and clock source * * %SKL_TKN_U32_ASTATE_COUNT: Number of valid entries in A-State table * * %SKL_TKN_U32_ASTATE_KCPS: Specifies the core load threshold (in kilo * cycles per second) below which DSP is clocked * from source specified by clock source. * * %SKL_TKN_U32_ASTATE_CLK_SRC: Clock source for A-State entry * * %SKL_TKN_U32_FMT_CFG_IDX: Format config index * * module_id and loadable flags dont have tokens as these values will be * read from the DSP FW manifest * * Tokens defined can be used either in the manifest or widget private data. * * SKL_TKN_MM is used as a suffix for all tokens that represent * module data in the manifest. */ enum SKL_TKNS { SKL_TKN_UUID = 1, SKL_TKN_U8_NUM_BLOCKS, SKL_TKN_U8_BLOCK_TYPE, SKL_TKN_U8_IN_PIN_TYPE, SKL_TKN_U8_OUT_PIN_TYPE, SKL_TKN_U8_DYN_IN_PIN, SKL_TKN_U8_DYN_OUT_PIN, SKL_TKN_U8_IN_QUEUE_COUNT, SKL_TKN_U8_OUT_QUEUE_COUNT, SKL_TKN_U8_TIME_SLOT, SKL_TKN_U8_CORE_ID, SKL_TKN_U8_MOD_TYPE, SKL_TKN_U8_CONN_TYPE, SKL_TKN_U8_DEV_TYPE, SKL_TKN_U8_HW_CONN_TYPE, SKL_TKN_U16_MOD_INST_ID, SKL_TKN_U16_BLOCK_SIZE, SKL_TKN_U32_MAX_MCPS, SKL_TKN_U32_MEM_PAGES, SKL_TKN_U32_OBS, SKL_TKN_U32_IBS, SKL_TKN_U32_VBUS_ID, SKL_TKN_U32_PARAMS_FIXUP, SKL_TKN_U32_CONVERTER, SKL_TKN_U32_PIPE_ID, SKL_TKN_U32_PIPE_CONN_TYPE, SKL_TKN_U32_PIPE_PRIORITY, SKL_TKN_U32_PIPE_MEM_PGS, SKL_TKN_U32_DIR_PIN_COUNT, SKL_TKN_U32_FMT_CH, SKL_TKN_U32_FMT_FREQ, SKL_TKN_U32_FMT_BIT_DEPTH, SKL_TKN_U32_FMT_SAMPLE_SIZE, SKL_TKN_U32_FMT_CH_CONFIG, SKL_TKN_U32_FMT_INTERLEAVE, SKL_TKN_U32_FMT_SAMPLE_TYPE, SKL_TKN_U32_FMT_CH_MAP, SKL_TKN_U32_PIN_MOD_ID, SKL_TKN_U32_PIN_INST_ID, SKL_TKN_U32_MOD_SET_PARAMS, SKL_TKN_U32_MOD_PARAM_ID, SKL_TKN_U32_CAPS_SET_PARAMS, SKL_TKN_U32_CAPS_PARAMS_ID, SKL_TKN_U32_CAPS_SIZE, SKL_TKN_U32_PROC_DOMAIN, SKL_TKN_U32_LIB_COUNT, SKL_TKN_STR_LIB_NAME, SKL_TKN_U32_PMODE, SKL_TKL_U32_D0I3_CAPS, /* Typo added at v4.10 */ SKL_TKN_U32_D0I3_CAPS = SKL_TKL_U32_D0I3_CAPS, SKL_TKN_U32_DMA_BUF_SIZE, SKL_TKN_U32_PIPE_DIRECTION, SKL_TKN_U32_PIPE_CONFIG_ID, SKL_TKN_U32_NUM_CONFIGS, SKL_TKN_U32_PATH_MEM_PGS, SKL_TKN_U32_CFG_FREQ, SKL_TKN_U8_CFG_CHAN, SKL_TKN_U8_CFG_BPS, SKL_TKN_CFG_MOD_RES_ID, SKL_TKN_CFG_MOD_FMT_ID, SKL_TKN_U8_NUM_MOD, SKL_TKN_MM_U8_MOD_IDX, SKL_TKN_MM_U8_NUM_RES, SKL_TKN_MM_U8_NUM_INTF, SKL_TKN_MM_U32_RES_ID, SKL_TKN_MM_U32_CPS, SKL_TKN_MM_U32_DMA_SIZE, SKL_TKN_MM_U32_CPC, SKL_TKN_MM_U32_RES_PIN_ID, SKL_TKN_MM_U32_INTF_PIN_ID, SKL_TKN_MM_U32_PIN_BUF, SKL_TKN_MM_U32_FMT_ID, SKL_TKN_MM_U32_NUM_IN_FMT, SKL_TKN_MM_U32_NUM_OUT_FMT, SKL_TKN_U32_ASTATE_IDX, SKL_TKN_U32_ASTATE_COUNT, SKL_TKN_U32_ASTATE_KCPS, SKL_TKN_U32_ASTATE_CLK_SRC, SKL_TKN_U32_FMT_CFG_IDX = 96, SKL_TKN_MAX = SKL_TKN_U32_FMT_CFG_IDX, }; #endif sound/skl-tplg-interface.h000064400000012320152640040160011534 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * skl-tplg-interface.h - Intel DSP FW private data interface * * Copyright (C) 2015 Intel Corp * Author: Jeeja KP * Nilofer, Samreen */ #ifndef __HDA_TPLG_INTERFACE_H__ #define __HDA_TPLG_INTERFACE_H__ #include /* * Default types range from 0~12. type can range from 0 to 0xff * SST types start at higher to avoid any overlapping in future */ #define SKL_CONTROL_TYPE_BYTE_TLV 0x100 #define SKL_CONTROL_TYPE_MIC_SELECT 0x102 #define SKL_CONTROL_TYPE_MULTI_IO_SELECT 0x103 #define SKL_CONTROL_TYPE_MULTI_IO_SELECT_DMIC 0x104 #define HDA_SST_CFG_MAX 900 /* size of copier cfg*/ #define MAX_IN_QUEUE 8 #define MAX_OUT_QUEUE 8 #define SKL_UUID_STR_SZ 40 /* Event types goes here */ /* Reserve event type 0 for no event handlers */ enum skl_event_types { SKL_EVENT_NONE = 0, SKL_MIXER_EVENT, SKL_MUX_EVENT, SKL_VMIXER_EVENT, SKL_PGA_EVENT }; /** * enum skl_ch_cfg - channel configuration * * @SKL_CH_CFG_MONO: One channel only * @SKL_CH_CFG_STEREO: L & R * @SKL_CH_CFG_2_1: L, R & LFE * @SKL_CH_CFG_3_0: L, C & R * @SKL_CH_CFG_3_1: L, C, R & LFE * @SKL_CH_CFG_QUATRO: L, R, Ls & Rs * @SKL_CH_CFG_4_0: L, C, R & Cs * @SKL_CH_CFG_5_0: L, C, R, Ls & Rs * @SKL_CH_CFG_5_1: L, C, R, Ls, Rs & LFE * @SKL_CH_CFG_DUAL_MONO: One channel replicated in two * @SKL_CH_CFG_I2S_DUAL_STEREO_0: Stereo(L,R) in 4 slots, 1st stream:[ L, R, -, - ] * @SKL_CH_CFG_I2S_DUAL_STEREO_1: Stereo(L,R) in 4 slots, 2nd stream:[ -, -, L, R ] * @SKL_CH_CFG_INVALID: Invalid */ enum skl_ch_cfg { SKL_CH_CFG_MONO = 0, SKL_CH_CFG_STEREO = 1, SKL_CH_CFG_2_1 = 2, SKL_CH_CFG_3_0 = 3, SKL_CH_CFG_3_1 = 4, SKL_CH_CFG_QUATRO = 5, SKL_CH_CFG_4_0 = 6, SKL_CH_CFG_5_0 = 7, SKL_CH_CFG_5_1 = 8, SKL_CH_CFG_DUAL_MONO = 9, SKL_CH_CFG_I2S_DUAL_STEREO_0 = 10, SKL_CH_CFG_I2S_DUAL_STEREO_1 = 11, SKL_CH_CFG_7_1 = 12, SKL_CH_CFG_4_CHANNEL = SKL_CH_CFG_7_1, SKL_CH_CFG_INVALID }; enum skl_module_type { SKL_MODULE_TYPE_MIXER = 0, SKL_MODULE_TYPE_COPIER, SKL_MODULE_TYPE_UPDWMIX, SKL_MODULE_TYPE_SRCINT, SKL_MODULE_TYPE_ALGO, SKL_MODULE_TYPE_BASE_OUTFMT, SKL_MODULE_TYPE_KPB, SKL_MODULE_TYPE_MIC_SELECT, }; enum skl_core_affinity { SKL_AFFINITY_CORE_0 = 0, SKL_AFFINITY_CORE_1, SKL_AFFINITY_CORE_MAX }; enum skl_pipe_conn_type { SKL_PIPE_CONN_TYPE_NONE = 0, SKL_PIPE_CONN_TYPE_FE, SKL_PIPE_CONN_TYPE_BE }; enum skl_hw_conn_type { SKL_CONN_NONE = 0, SKL_CONN_SOURCE = 1, SKL_CONN_SINK = 2 }; enum skl_dev_type { SKL_DEVICE_BT = 0x0, SKL_DEVICE_DMIC = 0x1, SKL_DEVICE_I2S = 0x2, SKL_DEVICE_SLIMBUS = 0x3, SKL_DEVICE_HDALINK = 0x4, SKL_DEVICE_HDAHOST = 0x5, SKL_DEVICE_NONE }; /** * enum skl_interleaving - interleaving style * * @SKL_INTERLEAVING_PER_CHANNEL: [s1_ch1...s1_chN,...,sM_ch1...sM_chN] * @SKL_INTERLEAVING_PER_SAMPLE: [s1_ch1...sM_ch1,...,s1_chN...sM_chN] */ enum skl_interleaving { SKL_INTERLEAVING_PER_CHANNEL = 0, SKL_INTERLEAVING_PER_SAMPLE = 1, }; enum skl_sample_type { SKL_SAMPLE_TYPE_INT_MSB = 0, SKL_SAMPLE_TYPE_INT_LSB = 1, SKL_SAMPLE_TYPE_INT_SIGNED = 2, SKL_SAMPLE_TYPE_INT_UNSIGNED = 3, SKL_SAMPLE_TYPE_FLOAT = 4 }; enum module_pin_type { /* All pins of the module takes same PCM inputs or outputs * e.g. mixout */ SKL_PIN_TYPE_HOMOGENEOUS, /* All pins of the module takes different PCM inputs or outputs * e.g mux */ SKL_PIN_TYPE_HETEROGENEOUS, }; enum skl_module_param_type { SKL_PARAM_DEFAULT = 0, SKL_PARAM_INIT, SKL_PARAM_SET, SKL_PARAM_BIND }; struct skl_dfw_algo_data { __u32 set_params:2; __u32 rsvd:30; __u32 param_id; __u32 max; char params[0]; } __attribute__((packed)); enum skl_tkn_dir { SKL_DIR_IN, SKL_DIR_OUT }; enum skl_tuple_type { SKL_TYPE_TUPLE, SKL_TYPE_DATA }; /* v4 configuration data */ struct skl_dfw_v4_module_pin { __u16 module_id; __u16 instance_id; } __attribute__((packed)); struct skl_dfw_v4_module_fmt { __u32 channels; __u32 freq; __u32 bit_depth; __u32 valid_bit_depth; __u32 ch_cfg; __u32 interleaving_style; __u32 sample_type; __u32 ch_map; } __attribute__((packed)); struct skl_dfw_v4_module_caps { __u32 set_params:2; __u32 rsvd:30; __u32 param_id; __u32 caps_size; __u32 caps[HDA_SST_CFG_MAX]; } __attribute__((packed)); struct skl_dfw_v4_pipe { __u8 pipe_id; __u8 pipe_priority; __u16 conn_type:4; __u16 rsvd:4; __u16 memory_pages:8; } __attribute__((packed)); struct skl_dfw_v4_module { char uuid[SKL_UUID_STR_SZ]; __u16 module_id; __u16 instance_id; __u32 max_mcps; __u32 mem_pages; __u32 obs; __u32 ibs; __u32 vbus_id; __u32 max_in_queue:8; __u32 max_out_queue:8; __u32 time_slot:8; __u32 core_id:4; __u32 rsvd1:4; __u32 module_type:8; __u32 conn_type:4; __u32 dev_type:4; __u32 hw_conn_type:4; __u32 rsvd2:12; __u32 params_fixup:8; __u32 converter:8; __u32 input_pin_type:1; __u32 output_pin_type:1; __u32 is_dynamic_in_pin:1; __u32 is_dynamic_out_pin:1; __u32 is_loadable:1; __u32 rsvd3:11; struct skl_dfw_v4_pipe pipe; struct skl_dfw_v4_module_fmt in_fmt[MAX_IN_QUEUE]; struct skl_dfw_v4_module_fmt out_fmt[MAX_OUT_QUEUE]; struct skl_dfw_v4_module_pin in_pin[MAX_IN_QUEUE]; struct skl_dfw_v4_module_pin out_pin[MAX_OUT_QUEUE]; struct skl_dfw_v4_module_caps caps; } __attribute__((packed)); #endif sound/sb16_csp.h000064400000006753152640040160007476 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * Copyright (c) 1999 by Uros Bizjak * Takashi Iwai * * SB16ASP/AWE32 CSP control */ #ifndef __SOUND_SB16_CSP_H #define __SOUND_SB16_CSP_H /* CSP modes */ #define SNDRV_SB_CSP_MODE_NONE 0x00 #define SNDRV_SB_CSP_MODE_DSP_READ 0x01 /* Record from DSP */ #define SNDRV_SB_CSP_MODE_DSP_WRITE 0x02 /* Play to DSP */ #define SNDRV_SB_CSP_MODE_QSOUND 0x04 /* QSound */ /* CSP load flags */ #define SNDRV_SB_CSP_LOAD_FROMUSER 0x01 #define SNDRV_SB_CSP_LOAD_INITBLOCK 0x02 /* CSP sample width */ #define SNDRV_SB_CSP_SAMPLE_8BIT 0x01 #define SNDRV_SB_CSP_SAMPLE_16BIT 0x02 /* CSP channels */ #define SNDRV_SB_CSP_MONO 0x01 #define SNDRV_SB_CSP_STEREO 0x02 /* CSP rates */ #define SNDRV_SB_CSP_RATE_8000 0x01 #define SNDRV_SB_CSP_RATE_11025 0x02 #define SNDRV_SB_CSP_RATE_22050 0x04 #define SNDRV_SB_CSP_RATE_44100 0x08 #define SNDRV_SB_CSP_RATE_ALL 0x0f /* CSP running state */ #define SNDRV_SB_CSP_ST_IDLE 0x00 #define SNDRV_SB_CSP_ST_LOADED 0x01 #define SNDRV_SB_CSP_ST_RUNNING 0x02 #define SNDRV_SB_CSP_ST_PAUSED 0x04 #define SNDRV_SB_CSP_ST_AUTO 0x08 #define SNDRV_SB_CSP_ST_QSOUND 0x10 /* maximum QSound value (180 degrees right) */ #define SNDRV_SB_CSP_QSOUND_MAX_RIGHT 0x20 /* maximum microcode RIFF file size */ #define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE 0x3000 /* microcode header */ struct snd_sb_csp_mc_header { char codec_name[16]; /* id name of codec */ unsigned short func_req; /* requested function */ }; /* microcode to be loaded */ struct snd_sb_csp_microcode { struct snd_sb_csp_mc_header info; unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE]; }; /* start CSP with sample_width in mono/stereo */ struct snd_sb_csp_start { int sample_width; /* sample width, look above */ int channels; /* channels, look above */ }; /* CSP information */ struct snd_sb_csp_info { char codec_name[16]; /* id name of codec */ unsigned short func_nr; /* function number */ unsigned int acc_format; /* accepted PCM formats */ unsigned short acc_channels; /* accepted channels */ unsigned short acc_width; /* accepted sample width */ unsigned short acc_rates; /* accepted sample rates */ unsigned short csp_mode; /* CSP mode, see above */ unsigned short run_channels; /* current channels */ unsigned short run_width; /* current sample width */ unsigned short version; /* version id: 0x10 - 0x1f */ unsigned short state; /* state bits */ }; /* HWDEP controls */ /* get CSP information */ #define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, struct snd_sb_csp_info) /* load microcode to CSP */ /* NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits) * defined for some architectures like MIPS, and it leads to build errors. * (x86 and co have 14-bit size, thus it's valid, though.) * As a workaround for skipping the size-limit check, here we don't use the * normal _IOW() macro but _IOC() with the manual argument. */ #define SNDRV_SB_CSP_IOCTL_LOAD_CODE \ _IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode)) /* unload microcode from CSP */ #define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12) /* start CSP */ #define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, struct snd_sb_csp_start) /* stop CSP */ #define SNDRV_SB_CSP_IOCTL_STOP _IO('H', 0x14) /* pause CSP and DMA transfer */ #define SNDRV_SB_CSP_IOCTL_PAUSE _IO('H', 0x15) /* restart CSP and DMA transfer */ #define SNDRV_SB_CSP_IOCTL_RESTART _IO('H', 0x16) #endif /* __SOUND_SB16_CSP_H */ sound/tlv.h000064400000007755152640040160006666 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ #ifndef __UAPI_SOUND_TLV_H #define __UAPI_SOUND_TLV_H #define SNDRV_CTL_TLVT_CONTAINER 0 /* one level down - group of TLVs */ #define SNDRV_CTL_TLVT_DB_SCALE 1 /* dB scale */ #define SNDRV_CTL_TLVT_DB_LINEAR 2 /* linear volume */ #define SNDRV_CTL_TLVT_DB_RANGE 3 /* dB range container */ #define SNDRV_CTL_TLVT_DB_MINMAX 4 /* dB scale with min/max */ #define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */ /* * channel-mapping TLV items * TLV length must match with num_channels */ #define SNDRV_CTL_TLVT_CHMAP_FIXED 0x101 /* fixed channel position */ #define SNDRV_CTL_TLVT_CHMAP_VAR 0x102 /* channels freely swappable */ #define SNDRV_CTL_TLVT_CHMAP_PAIRED 0x103 /* pair-wise swappable */ /* * TLV structure is right behind the struct snd_ctl_tlv: * unsigned int type - see SNDRV_CTL_TLVT_* * unsigned int length * .... data aligned to sizeof(unsigned int), use * block_length = (length + (sizeof(unsigned int) - 1)) & * ~(sizeof(unsigned int) - 1)) .... */ #define SNDRV_CTL_TLVD_ITEM(type, ...) \ (type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__ #define SNDRV_CTL_TLVD_LENGTH(...) \ ((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ })) /* Accessor offsets for TLV data items */ #define SNDRV_CTL_TLVO_TYPE 0 #define SNDRV_CTL_TLVO_LEN 1 #define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__) #define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \ } #define SNDRV_CTL_TLVD_DB_SCALE_MASK 0xffff #define SNDRV_CTL_TLVD_DB_SCALE_MUTE 0x10000 #define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \ (min), \ ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) | \ ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0)) #define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ } /* Accessor offsets for min, mute and step items in dB scale type TLV */ #define SNDRV_CTL_TLVO_DB_SCALE_MIN 2 #define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP 3 /* dB scale specified with min/max values instead of step */ #define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ } #define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ } /* Accessor offsets for min, max items in db-minmax types of TLV. */ #define SNDRV_CTL_TLVO_DB_MINMAX_MIN 2 #define SNDRV_CTL_TLVO_DB_MINMAX_MAX 3 /* linear volume between min_dB and max_dB (.01dB unit) */ #define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ } /* Accessor offsets for min, max items in db-linear type of TLV. */ #define SNDRV_CTL_TLVO_DB_LINEAR_MIN 2 #define SNDRV_CTL_TLVO_DB_LINEAR_MAX 3 /* dB range container: * Items in dB range container must be ordered by their values and by their * dB values. This implies that larger values must correspond with larger * dB values (which is also required for all other mixer controls). */ /* Each item is: */ #define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__) #define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \ } #define SNDRV_CTL_TLVD_DB_GAIN_MUTE -9999999 #endif tiffconf.h000064400000000372152640040160006513 0ustar00#ifndef TIFFCONF_H_MULTILIB #define TIFFCONF_H_MULTILIB #include #if __WORDSIZE == 32 # include "tiffconf-32.h" #elif __WORDSIZE == 64 # include "tiffconf-64.h" #else # error "unexpected value for __WORDSIZE macro" #endif #endif scsi/fc/fc_fs.h000064400000030117152640040160007326 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * Copyright(c) 2007 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. * * Maintained at www.Open-FCoE.org */ #ifndef _FC_FS_H_ #define _FC_FS_H_ #include /* * Fibre Channel Framing and Signalling definitions. * From T11 FC-FS-2 Rev 0.90 - 9 August 2005. */ /* * Frame header */ struct fc_frame_header { __u8 fh_r_ctl; /* routing control */ __u8 fh_d_id[3]; /* Destination ID */ __u8 fh_cs_ctl; /* class of service control / pri */ __u8 fh_s_id[3]; /* Source ID */ __u8 fh_type; /* see enum fc_fh_type below */ __u8 fh_f_ctl[3]; /* frame control */ __u8 fh_seq_id; /* sequence ID */ __u8 fh_df_ctl; /* data field control */ __be16 fh_seq_cnt; /* sequence count */ __be16 fh_ox_id; /* originator exchange ID */ __be16 fh_rx_id; /* responder exchange ID */ __be32 fh_parm_offset; /* parameter or relative offset */ }; #define FC_FRAME_HEADER_LEN 24 /* expected length of structure */ #define FC_MAX_PAYLOAD 2112U /* max payload length in bytes */ #define FC_MIN_MAX_PAYLOAD 256U /* lower limit on max payload */ #define FC_MAX_FRAME (FC_MAX_PAYLOAD + FC_FRAME_HEADER_LEN) #define FC_MIN_MAX_FRAME (FC_MIN_MAX_PAYLOAD + FC_FRAME_HEADER_LEN) /* * fh_r_ctl - Routing control definitions. */ /* * FC-4 device_data. */ enum fc_rctl { FC_RCTL_DD_UNCAT = 0x00, /* uncategorized information */ FC_RCTL_DD_SOL_DATA = 0x01, /* solicited data */ FC_RCTL_DD_UNSOL_CTL = 0x02, /* unsolicited control */ FC_RCTL_DD_SOL_CTL = 0x03, /* solicited control or reply */ FC_RCTL_DD_UNSOL_DATA = 0x04, /* unsolicited data */ FC_RCTL_DD_DATA_DESC = 0x05, /* data descriptor */ FC_RCTL_DD_UNSOL_CMD = 0x06, /* unsolicited command */ FC_RCTL_DD_CMD_STATUS = 0x07, /* command status */ #define FC_RCTL_ILS_REQ FC_RCTL_DD_UNSOL_CTL /* ILS request */ #define FC_RCTL_ILS_REP FC_RCTL_DD_SOL_CTL /* ILS reply */ /* * Extended Link_Data */ FC_RCTL_ELS_REQ = 0x22, /* extended link services request */ FC_RCTL_ELS_REP = 0x23, /* extended link services reply */ FC_RCTL_ELS4_REQ = 0x32, /* FC-4 ELS request */ FC_RCTL_ELS4_REP = 0x33, /* FC-4 ELS reply */ /* * Optional Extended Headers */ FC_RCTL_VFTH = 0x50, /* virtual fabric tagging header */ FC_RCTL_IFRH = 0x51, /* inter-fabric routing header */ FC_RCTL_ENCH = 0x52, /* encapsulation header */ /* * Basic Link Services fh_r_ctl values. */ FC_RCTL_BA_NOP = 0x80, /* basic link service NOP */ FC_RCTL_BA_ABTS = 0x81, /* basic link service abort */ FC_RCTL_BA_RMC = 0x82, /* remove connection */ FC_RCTL_BA_ACC = 0x84, /* basic accept */ FC_RCTL_BA_RJT = 0x85, /* basic reject */ FC_RCTL_BA_PRMT = 0x86, /* dedicated connection preempted */ /* * Link Control Information. */ FC_RCTL_ACK_1 = 0xc0, /* acknowledge_1 */ FC_RCTL_ACK_0 = 0xc1, /* acknowledge_0 */ FC_RCTL_P_RJT = 0xc2, /* port reject */ FC_RCTL_F_RJT = 0xc3, /* fabric reject */ FC_RCTL_P_BSY = 0xc4, /* port busy */ FC_RCTL_F_BSY = 0xc5, /* fabric busy to data frame */ FC_RCTL_F_BSYL = 0xc6, /* fabric busy to link control frame */ FC_RCTL_LCR = 0xc7, /* link credit reset */ FC_RCTL_END = 0xc9, /* end */ }; /* incomplete list of definitions */ /* * R_CTL names initializer. * Please keep this matching the above definitions. */ #define FC_RCTL_NAMES_INIT { \ [FC_RCTL_DD_UNCAT] = "uncat", \ [FC_RCTL_DD_SOL_DATA] = "sol data", \ [FC_RCTL_DD_UNSOL_CTL] = "unsol ctl", \ [FC_RCTL_DD_SOL_CTL] = "sol ctl/reply", \ [FC_RCTL_DD_UNSOL_DATA] = "unsol data", \ [FC_RCTL_DD_DATA_DESC] = "data desc", \ [FC_RCTL_DD_UNSOL_CMD] = "unsol cmd", \ [FC_RCTL_DD_CMD_STATUS] = "cmd status", \ [FC_RCTL_ELS_REQ] = "ELS req", \ [FC_RCTL_ELS_REP] = "ELS rep", \ [FC_RCTL_ELS4_REQ] = "FC-4 ELS req", \ [FC_RCTL_ELS4_REP] = "FC-4 ELS rep", \ [FC_RCTL_BA_NOP] = "BLS NOP", \ [FC_RCTL_BA_ABTS] = "BLS abort", \ [FC_RCTL_BA_RMC] = "BLS remove connection", \ [FC_RCTL_BA_ACC] = "BLS accept", \ [FC_RCTL_BA_RJT] = "BLS reject", \ [FC_RCTL_BA_PRMT] = "BLS dedicated connection preempted", \ [FC_RCTL_ACK_1] = "LC ACK_1", \ [FC_RCTL_ACK_0] = "LC ACK_0", \ [FC_RCTL_P_RJT] = "LC port reject", \ [FC_RCTL_F_RJT] = "LC fabric reject", \ [FC_RCTL_P_BSY] = "LC port busy", \ [FC_RCTL_F_BSY] = "LC fabric busy to data frame", \ [FC_RCTL_F_BSYL] = "LC fabric busy to link control frame",\ [FC_RCTL_LCR] = "LC link credit reset", \ [FC_RCTL_END] = "LC end", \ } /* * Well-known fabric addresses. */ enum fc_well_known_fid { FC_FID_NONE = 0x000000, /* No destination */ FC_FID_BCAST = 0xffffff, /* broadcast */ FC_FID_FLOGI = 0xfffffe, /* fabric login */ FC_FID_FCTRL = 0xfffffd, /* fabric controller */ FC_FID_DIR_SERV = 0xfffffc, /* directory server */ FC_FID_TIME_SERV = 0xfffffb, /* time server */ FC_FID_MGMT_SERV = 0xfffffa, /* management server */ FC_FID_QOS = 0xfffff9, /* QoS Facilitator */ FC_FID_ALIASES = 0xfffff8, /* alias server (FC-PH2) */ FC_FID_SEC_KEY = 0xfffff7, /* Security key dist. server */ FC_FID_CLOCK = 0xfffff6, /* clock synch server */ FC_FID_MCAST_SERV = 0xfffff5, /* multicast server */ }; #define FC_FID_WELL_KNOWN_MAX 0xffffff /* highest well-known fabric ID */ #define FC_FID_WELL_KNOWN_BASE 0xfffff5 /* start of well-known fabric ID */ /* * Other well-known addresses, outside the above contiguous range. */ #define FC_FID_DOM_MGR 0xfffc00 /* domain manager base */ /* * Fabric ID bytes. */ #define FC_FID_DOMAIN 0 #define FC_FID_PORT 1 #define FC_FID_LINK 2 /* * fh_type codes */ enum fc_fh_type { FC_TYPE_BLS = 0x00, /* basic link service */ FC_TYPE_ELS = 0x01, /* extended link service */ FC_TYPE_IP = 0x05, /* IP over FC, RFC 4338 */ FC_TYPE_FCP = 0x08, /* SCSI FCP */ FC_TYPE_CT = 0x20, /* Fibre Channel Services (FC-CT) */ FC_TYPE_ILS = 0x22, /* internal link service */ FC_TYPE_NVME = 0x28, /* FC-NVME */ }; /* * FC_TYPE names initializer. * Please keep this matching the above definitions. */ #define FC_TYPE_NAMES_INIT { \ [FC_TYPE_BLS] = "BLS", \ [FC_TYPE_ELS] = "ELS", \ [FC_TYPE_IP] = "IP", \ [FC_TYPE_FCP] = "FCP", \ [FC_TYPE_CT] = "CT", \ [FC_TYPE_ILS] = "ILS", \ [FC_TYPE_NVME] = "NVME", \ } /* * Exchange IDs. */ #define FC_XID_UNKNOWN 0xffff /* unknown exchange ID */ #define FC_XID_MIN 0x0 /* supported min exchange ID */ #define FC_XID_MAX 0xfffe /* supported max exchange ID */ /* * fh_f_ctl - Frame control flags. */ #define FC_FC_EX_CTX (1 << 23) /* sent by responder to exchange */ #define FC_FC_SEQ_CTX (1 << 22) /* sent by responder to sequence */ #define FC_FC_FIRST_SEQ (1 << 21) /* first sequence of this exchange */ #define FC_FC_LAST_SEQ (1 << 20) /* last sequence of this exchange */ #define FC_FC_END_SEQ (1 << 19) /* last frame of sequence */ #define FC_FC_END_CONN (1 << 18) /* end of class 1 connection pending */ #define FC_FC_RES_B17 (1 << 17) /* reserved */ #define FC_FC_SEQ_INIT (1 << 16) /* transfer of sequence initiative */ #define FC_FC_X_ID_REASS (1 << 15) /* exchange ID has been changed */ #define FC_FC_X_ID_INVAL (1 << 14) /* exchange ID invalidated */ #define FC_FC_ACK_1 (1 << 12) /* 13:12 = 1: ACK_1 expected */ #define FC_FC_ACK_N (2 << 12) /* 13:12 = 2: ACK_N expected */ #define FC_FC_ACK_0 (3 << 12) /* 13:12 = 3: ACK_0 expected */ #define FC_FC_RES_B11 (1 << 11) /* reserved */ #define FC_FC_RES_B10 (1 << 10) /* reserved */ #define FC_FC_RETX_SEQ (1 << 9) /* retransmitted sequence */ #define FC_FC_UNI_TX (1 << 8) /* unidirectional transmit (class 1) */ #define FC_FC_CONT_SEQ(i) ((i) << 6) #define FC_FC_ABT_SEQ(i) ((i) << 4) #define FC_FC_REL_OFF (1 << 3) /* parameter is relative offset */ #define FC_FC_RES2 (1 << 2) /* reserved */ #define FC_FC_FILL(i) ((i) & 3) /* 1:0: bytes of trailing fill */ /* * BA_ACC payload. */ struct fc_ba_acc { __u8 ba_seq_id_val; /* SEQ_ID validity */ #define FC_BA_SEQ_ID_VAL 0x80 __u8 ba_seq_id; /* SEQ_ID of seq last deliverable */ __u8 ba_resvd[2]; /* reserved */ __be16 ba_ox_id; /* OX_ID for aborted seq or exch */ __be16 ba_rx_id; /* RX_ID for aborted seq or exch */ __be16 ba_low_seq_cnt; /* low SEQ_CNT of aborted seq */ __be16 ba_high_seq_cnt; /* high SEQ_CNT of aborted seq */ }; /* * BA_RJT: Basic Reject payload. */ struct fc_ba_rjt { __u8 br_resvd; /* reserved */ __u8 br_reason; /* reason code */ __u8 br_explan; /* reason explanation */ __u8 br_vendor; /* vendor unique code */ }; /* * BA_RJT reason codes. * From FS-2. */ enum fc_ba_rjt_reason { FC_BA_RJT_NONE = 0, /* in software this means no reject */ FC_BA_RJT_INVL_CMD = 0x01, /* invalid command code */ FC_BA_RJT_LOG_ERR = 0x03, /* logical error */ FC_BA_RJT_LOG_BUSY = 0x05, /* logical busy */ FC_BA_RJT_PROTO_ERR = 0x07, /* protocol error */ FC_BA_RJT_UNABLE = 0x09, /* unable to perform request */ FC_BA_RJT_VENDOR = 0xff, /* vendor-specific (see br_vendor) */ }; /* * BA_RJT reason code explanations. */ enum fc_ba_rjt_explan { FC_BA_RJT_EXP_NONE = 0x00, /* no additional expanation */ FC_BA_RJT_INV_XID = 0x03, /* invalid OX_ID-RX_ID combination */ FC_BA_RJT_ABT = 0x05, /* sequence aborted, no seq info */ }; /* * P_RJT or F_RJT: Port Reject or Fabric Reject parameter field. */ struct fc_pf_rjt { __u8 rj_action; /* reserved */ __u8 rj_reason; /* reason code */ __u8 rj_resvd; /* reserved */ __u8 rj_vendor; /* vendor unique code */ }; /* * P_RJT and F_RJT reject reason codes. */ enum fc_pf_rjt_reason { FC_RJT_NONE = 0, /* non-reject (reserved by standard) */ FC_RJT_INVL_DID = 0x01, /* invalid destination ID */ FC_RJT_INVL_SID = 0x02, /* invalid source ID */ FC_RJT_P_UNAV_T = 0x03, /* port unavailable, temporary */ FC_RJT_P_UNAV = 0x04, /* port unavailable, permanent */ FC_RJT_CLS_UNSUP = 0x05, /* class not supported */ FC_RJT_DEL_USAGE = 0x06, /* delimiter usage error */ FC_RJT_TYPE_UNSUP = 0x07, /* type not supported */ FC_RJT_LINK_CTL = 0x08, /* invalid link control */ FC_RJT_R_CTL = 0x09, /* invalid R_CTL field */ FC_RJT_F_CTL = 0x0a, /* invalid F_CTL field */ FC_RJT_OX_ID = 0x0b, /* invalid originator exchange ID */ FC_RJT_RX_ID = 0x0c, /* invalid responder exchange ID */ FC_RJT_SEQ_ID = 0x0d, /* invalid sequence ID */ FC_RJT_DF_CTL = 0x0e, /* invalid DF_CTL field */ FC_RJT_SEQ_CNT = 0x0f, /* invalid SEQ_CNT field */ FC_RJT_PARAM = 0x10, /* invalid parameter field */ FC_RJT_EXCH_ERR = 0x11, /* exchange error */ FC_RJT_PROTO = 0x12, /* protocol error */ FC_RJT_LEN = 0x13, /* incorrect length */ FC_RJT_UNEXP_ACK = 0x14, /* unexpected ACK */ FC_RJT_FAB_CLASS = 0x15, /* class unsupported by fabric entity */ FC_RJT_LOGI_REQ = 0x16, /* login required */ FC_RJT_SEQ_XS = 0x17, /* excessive sequences attempted */ FC_RJT_EXCH_EST = 0x18, /* unable to establish exchange */ FC_RJT_FAB_UNAV = 0x1a, /* fabric unavailable */ FC_RJT_VC_ID = 0x1b, /* invalid VC_ID (class 4) */ FC_RJT_CS_CTL = 0x1c, /* invalid CS_CTL field */ FC_RJT_INSUF_RES = 0x1d, /* insuff. resources for VC (Class 4) */ FC_RJT_INVL_CLS = 0x1f, /* invalid class of service */ FC_RJT_PREEMT_RJT = 0x20, /* preemption request rejected */ FC_RJT_PREEMT_DIS = 0x21, /* preemption not enabled */ FC_RJT_MCAST_ERR = 0x22, /* multicast error */ FC_RJT_MCAST_ET = 0x23, /* multicast error terminate */ FC_RJT_PRLI_REQ = 0x24, /* process login required */ FC_RJT_INVL_ATT = 0x25, /* invalid attachment */ FC_RJT_VENDOR = 0xff, /* vendor specific reject */ }; /* default timeout values */ #define FC_DEF_E_D_TOV 2000UL #define FC_DEF_R_A_TOV 10000UL #endif /* _FC_FS_H_ */ scsi/fc/fc_els.h000064400000115256152640040160007511 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * Copyright(c) 2007 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. * * Maintained at www.Open-FCoE.org */ #ifndef _FC_ELS_H_ #define _FC_ELS_H_ #include #include /* * Fibre Channel Switch - Enhanced Link Services definitions. * From T11 FC-LS Rev 1.2 June 7, 2005. */ /* * ELS Command codes - byte 0 of the frame payload */ enum fc_els_cmd { ELS_LS_RJT = 0x01, /* ESL reject */ ELS_LS_ACC = 0x02, /* ESL Accept */ ELS_PLOGI = 0x03, /* N_Port login */ ELS_FLOGI = 0x04, /* F_Port login */ ELS_LOGO = 0x05, /* Logout */ ELS_ABTX = 0x06, /* Abort exchange - obsolete */ ELS_RCS = 0x07, /* read connection status */ ELS_RES = 0x08, /* read exchange status block */ ELS_RSS = 0x09, /* read sequence status block */ ELS_RSI = 0x0a, /* read sequence initiative */ ELS_ESTS = 0x0b, /* establish streaming */ ELS_ESTC = 0x0c, /* estimate credit */ ELS_ADVC = 0x0d, /* advise credit */ ELS_RTV = 0x0e, /* read timeout value */ ELS_RLS = 0x0f, /* read link error status block */ ELS_ECHO = 0x10, /* echo */ ELS_TEST = 0x11, /* test */ ELS_RRQ = 0x12, /* reinstate recovery qualifier */ ELS_REC = 0x13, /* read exchange concise */ ELS_SRR = 0x14, /* sequence retransmission request */ ELS_FPIN = 0x16, /* Fabric Performance Impact Notification */ ELS_EDC = 0x17, /* Exchange Diagnostic Capabilities */ ELS_RDP = 0x18, /* Read Diagnostic Parameters */ ELS_RDF = 0x19, /* Register Diagnostic Functions */ ELS_PRLI = 0x20, /* process login */ ELS_PRLO = 0x21, /* process logout */ ELS_SCN = 0x22, /* state change notification */ ELS_TPLS = 0x23, /* test process login state */ ELS_TPRLO = 0x24, /* third party process logout */ ELS_LCLM = 0x25, /* login control list mgmt (obs) */ ELS_GAID = 0x30, /* get alias_ID */ ELS_FACT = 0x31, /* fabric activate alias_id */ ELS_FDACDT = 0x32, /* fabric deactivate alias_id */ ELS_NACT = 0x33, /* N-port activate alias_id */ ELS_NDACT = 0x34, /* N-port deactivate alias_id */ ELS_QOSR = 0x40, /* quality of service request */ ELS_RVCS = 0x41, /* read virtual circuit status */ ELS_PDISC = 0x50, /* discover N_port service params */ ELS_FDISC = 0x51, /* discover F_port service params */ ELS_ADISC = 0x52, /* discover address */ ELS_RNC = 0x53, /* report node cap (obs) */ ELS_FARP_REQ = 0x54, /* FC ARP request */ ELS_FARP_REPL = 0x55, /* FC ARP reply */ ELS_RPS = 0x56, /* read port status block */ ELS_RPL = 0x57, /* read port list */ ELS_RPBC = 0x58, /* read port buffer condition */ ELS_FAN = 0x60, /* fabric address notification */ ELS_RSCN = 0x61, /* registered state change notification */ ELS_SCR = 0x62, /* state change registration */ ELS_RNFT = 0x63, /* report node FC-4 types */ ELS_CSR = 0x68, /* clock synch. request */ ELS_CSU = 0x69, /* clock synch. update */ ELS_LINIT = 0x70, /* loop initialize */ ELS_LSTS = 0x72, /* loop status */ ELS_RNID = 0x78, /* request node ID data */ ELS_RLIR = 0x79, /* registered link incident report */ ELS_LIRR = 0x7a, /* link incident record registration */ ELS_SRL = 0x7b, /* scan remote loop */ ELS_SBRP = 0x7c, /* set bit-error reporting params */ ELS_RPSC = 0x7d, /* report speed capabilities */ ELS_QSA = 0x7e, /* query security attributes */ ELS_EVFP = 0x7f, /* exchange virt. fabrics params */ ELS_LKA = 0x80, /* link keep-alive */ ELS_AUTH_ELS = 0x90, /* authentication ELS */ }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_ELS_CMDS_INIT { \ [ELS_LS_RJT] = "LS_RJT", \ [ELS_LS_ACC] = "LS_ACC", \ [ELS_PLOGI] = "PLOGI", \ [ELS_FLOGI] = "FLOGI", \ [ELS_LOGO] = "LOGO", \ [ELS_ABTX] = "ABTX", \ [ELS_RCS] = "RCS", \ [ELS_RES] = "RES", \ [ELS_RSS] = "RSS", \ [ELS_RSI] = "RSI", \ [ELS_ESTS] = "ESTS", \ [ELS_ESTC] = "ESTC", \ [ELS_ADVC] = "ADVC", \ [ELS_RTV] = "RTV", \ [ELS_RLS] = "RLS", \ [ELS_ECHO] = "ECHO", \ [ELS_TEST] = "TEST", \ [ELS_RRQ] = "RRQ", \ [ELS_REC] = "REC", \ [ELS_SRR] = "SRR", \ [ELS_FPIN] = "FPIN", \ [ELS_EDC] = "EDC", \ [ELS_RDP] = "RDP", \ [ELS_RDF] = "RDF", \ [ELS_PRLI] = "PRLI", \ [ELS_PRLO] = "PRLO", \ [ELS_SCN] = "SCN", \ [ELS_TPLS] = "TPLS", \ [ELS_TPRLO] = "TPRLO", \ [ELS_LCLM] = "LCLM", \ [ELS_GAID] = "GAID", \ [ELS_FACT] = "FACT", \ [ELS_FDACDT] = "FDACDT", \ [ELS_NACT] = "NACT", \ [ELS_NDACT] = "NDACT", \ [ELS_QOSR] = "QOSR", \ [ELS_RVCS] = "RVCS", \ [ELS_PDISC] = "PDISC", \ [ELS_FDISC] = "FDISC", \ [ELS_ADISC] = "ADISC", \ [ELS_RNC] = "RNC", \ [ELS_FARP_REQ] = "FARP_REQ", \ [ELS_FARP_REPL] = "FARP_REPL", \ [ELS_RPS] = "RPS", \ [ELS_RPL] = "RPL", \ [ELS_RPBC] = "RPBC", \ [ELS_FAN] = "FAN", \ [ELS_RSCN] = "RSCN", \ [ELS_SCR] = "SCR", \ [ELS_RNFT] = "RNFT", \ [ELS_CSR] = "CSR", \ [ELS_CSU] = "CSU", \ [ELS_LINIT] = "LINIT", \ [ELS_LSTS] = "LSTS", \ [ELS_RNID] = "RNID", \ [ELS_RLIR] = "RLIR", \ [ELS_LIRR] = "LIRR", \ [ELS_SRL] = "SRL", \ [ELS_SBRP] = "SBRP", \ [ELS_RPSC] = "RPSC", \ [ELS_QSA] = "QSA", \ [ELS_EVFP] = "EVFP", \ [ELS_LKA] = "LKA", \ [ELS_AUTH_ELS] = "AUTH_ELS", \ } /* * LS_ACC payload. */ struct fc_els_ls_acc { __u8 la_cmd; /* command code ELS_LS_ACC */ __u8 la_resv[3]; /* reserved */ }; /* * ELS reject payload. */ struct fc_els_ls_rjt { __u8 er_cmd; /* command code ELS_LS_RJT */ __u8 er_resv[4]; /* reserved must be zero */ __u8 er_reason; /* reason (enum fc_els_rjt_reason below) */ __u8 er_explan; /* explanation (enum fc_els_rjt_explan below) */ __u8 er_vendor; /* vendor specific code */ }; /* * ELS reject reason codes (er_reason). */ enum fc_els_rjt_reason { ELS_RJT_NONE = 0, /* no reject - not to be sent */ ELS_RJT_INVAL = 0x01, /* invalid ELS command code */ ELS_RJT_LOGIC = 0x03, /* logical error */ ELS_RJT_BUSY = 0x05, /* logical busy */ ELS_RJT_PROT = 0x07, /* protocol error */ ELS_RJT_UNAB = 0x09, /* unable to perform command request */ ELS_RJT_UNSUP = 0x0b, /* command not supported */ ELS_RJT_INPROG = 0x0e, /* command already in progress */ ELS_RJT_FIP = 0x20, /* FIP error */ ELS_RJT_VENDOR = 0xff, /* vendor specific error */ }; /* * reason code explanation (er_explan). */ enum fc_els_rjt_explan { ELS_EXPL_NONE = 0x00, /* No additional explanation */ ELS_EXPL_SPP_OPT_ERR = 0x01, /* service parameter error - options */ ELS_EXPL_SPP_ICTL_ERR = 0x03, /* service parm error - initiator ctl */ ELS_EXPL_AH = 0x11, /* invalid association header */ ELS_EXPL_AH_REQ = 0x13, /* association_header required */ ELS_EXPL_SID = 0x15, /* invalid originator S_ID */ ELS_EXPL_OXID_RXID = 0x17, /* invalid OX_ID-RX_ID combination */ ELS_EXPL_INPROG = 0x19, /* Request already in progress */ ELS_EXPL_PLOGI_REQD = 0x1e, /* N_Port login required */ ELS_EXPL_INSUF_RES = 0x29, /* insufficient resources */ ELS_EXPL_UNAB_DATA = 0x2a, /* unable to supply requested data */ ELS_EXPL_UNSUPR = 0x2c, /* Request not supported */ ELS_EXPL_INV_LEN = 0x2d, /* Invalid payload length */ ELS_EXPL_NOT_NEIGHBOR = 0x62, /* VN2VN_Port not in neighbor set */ /* TBD - above definitions incomplete */ }; /* * Link Service TLV Descriptor Tag Values */ enum fc_ls_tlv_dtag { ELS_DTAG_LS_REQ_INFO = 0x00000001, /* Link Service Request Information Descriptor */ ELS_DTAG_LNK_FAULT_CAP = 0x0001000D, /* Link Fault Capability Descriptor */ ELS_DTAG_CG_SIGNAL_CAP = 0x0001000F, /* Congestion Signaling Capability Descriptor */ ELS_DTAG_LNK_INTEGRITY = 0x00020001, /* Link Integrity Notification Descriptor */ ELS_DTAG_DELIVERY = 0x00020002, /* Delivery Notification Descriptor */ ELS_DTAG_PEER_CONGEST = 0x00020003, /* Peer Congestion Notification Descriptor */ ELS_DTAG_CONGESTION = 0x00020004, /* Congestion Notification Descriptor */ ELS_DTAG_FPIN_REGISTER = 0x00030001, /* FPIN Registration Descriptor */ }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_LS_TLV_DTAG_INIT { \ { ELS_DTAG_LS_REQ_INFO, "Link Service Request Information" }, \ { ELS_DTAG_LNK_FAULT_CAP, "Link Fault Capability" }, \ { ELS_DTAG_CG_SIGNAL_CAP, "Congestion Signaling Capability" }, \ { ELS_DTAG_LNK_INTEGRITY, "Link Integrity Notification" }, \ { ELS_DTAG_DELIVERY, "Delivery Notification Present" }, \ { ELS_DTAG_PEER_CONGEST, "Peer Congestion Notification" }, \ { ELS_DTAG_CONGESTION, "Congestion Notification" }, \ { ELS_DTAG_FPIN_REGISTER, "FPIN Registration" }, \ } /* * Generic Link Service TLV Descriptor format * * This structure, as it defines no payload, will also be referred to * as the "tlv header" - which contains the tag and len fields. */ struct fc_tlv_desc { __be32 desc_tag; /* Notification Descriptor Tag */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __u8 desc_value[0]; /* Descriptor Value */ }; /* Descriptor tag and len fields are considered the mandatory header * for a descriptor */ #define FC_TLV_DESC_HDR_SZ sizeof(struct fc_tlv_desc) /* * Macro, used when initializing payloads, to return the descriptor length. * Length is size of descriptor minus the tag and len fields. */ #define FC_TLV_DESC_LENGTH_FROM_SZ(desc) \ (sizeof(desc) - FC_TLV_DESC_HDR_SZ) /* Macro, used on received payloads, to return the descriptor length */ #define FC_TLV_DESC_SZ_FROM_LENGTH(tlv) \ (__be32_to_cpu((tlv)->desc_len) + FC_TLV_DESC_HDR_SZ) /* * This helper is used to walk descriptors in a descriptor list. * Given the address of the current descriptor, which minimally contains a * tag and len field, calculate the address of the next descriptor based * on the len field. */ static __inline__ void *fc_tlv_next_desc(void *desc) { struct fc_tlv_desc *tlv = desc; return (desc + FC_TLV_DESC_SZ_FROM_LENGTH(tlv)); } /* * Link Service Request Information Descriptor */ struct fc_els_lsri_desc { __be32 desc_tag; /* descriptor tag (0x0000 0001) */ __be32 desc_len; /* Length of Descriptor (in bytes) (4). * Size of descriptor excluding * desc_tag and desc_len fields. */ struct { __u8 cmd; /* ELS cmd byte */ __u8 bytes[3]; /* bytes 1..3 */ } rqst_w0; /* Request word 0 */ }; /* * Common service parameters (N ports). */ struct fc_els_csp { __u8 sp_hi_ver; /* highest version supported (obs.) */ __u8 sp_lo_ver; /* highest version supported (obs.) */ __be16 sp_bb_cred; /* buffer-to-buffer credits */ __be16 sp_features; /* common feature flags */ __be16 sp_bb_data; /* b-b state number and data field sz */ union { struct { __be16 _sp_tot_seq; /* total concurrent sequences */ __be16 _sp_rel_off; /* rel. offset by info cat */ } sp_plogi; struct { __be32 _sp_r_a_tov; /* resource alloc. timeout msec */ } sp_flogi_acc; } sp_u; __be32 sp_e_d_tov; /* error detect timeout value */ }; #define sp_tot_seq sp_u.sp_plogi._sp_tot_seq #define sp_rel_off sp_u.sp_plogi._sp_rel_off #define sp_r_a_tov sp_u.sp_flogi_acc._sp_r_a_tov #define FC_SP_BB_DATA_MASK 0xfff /* mask for data field size in sp_bb_data */ /* * Minimum and maximum values for max data field size in service parameters. */ #define FC_SP_MIN_MAX_PAYLOAD FC_MIN_MAX_PAYLOAD #define FC_SP_MAX_MAX_PAYLOAD FC_MAX_PAYLOAD /* * sp_features */ #define FC_SP_FT_NPIV 0x8000 /* multiple N_Port_ID support (FLOGI) */ #define FC_SP_FT_CIRO 0x8000 /* continuously increasing rel off (PLOGI) */ #define FC_SP_FT_CLAD 0x8000 /* clean address (in FLOGI LS_ACC) */ #define FC_SP_FT_RAND 0x4000 /* random relative offset */ #define FC_SP_FT_VAL 0x2000 /* valid vendor version level */ #define FC_SP_FT_NPIV_ACC 0x2000 /* NPIV assignment (FLOGI LS_ACC) */ #define FC_SP_FT_FPORT 0x1000 /* F port (1) vs. N port (0) */ #define FC_SP_FT_ABB 0x0800 /* alternate BB_credit management */ #define FC_SP_FT_EDTR 0x0400 /* E_D_TOV Resolution is nanoseconds */ #define FC_SP_FT_MCAST 0x0200 /* multicast */ #define FC_SP_FT_BCAST 0x0100 /* broadcast */ #define FC_SP_FT_HUNT 0x0080 /* hunt group */ #define FC_SP_FT_SIMP 0x0040 /* dedicated simplex */ #define FC_SP_FT_SEC 0x0020 /* reserved for security */ #define FC_SP_FT_CSYN 0x0010 /* clock synch. supported */ #define FC_SP_FT_RTTOV 0x0008 /* R_T_TOV value 100 uS, else 100 mS */ #define FC_SP_FT_HALF 0x0004 /* dynamic half duplex */ #define FC_SP_FT_SEQC 0x0002 /* SEQ_CNT */ #define FC_SP_FT_PAYL 0x0001 /* FLOGI payload length 256, else 116 */ /* * Class-specific service parameters. */ struct fc_els_cssp { __be16 cp_class; /* class flags */ __be16 cp_init; /* initiator flags */ __be16 cp_recip; /* recipient flags */ __be16 cp_rdfs; /* receive data field size */ __be16 cp_con_seq; /* concurrent sequences */ __be16 cp_ee_cred; /* N-port end-to-end credit */ __u8 cp_resv1; /* reserved */ __u8 cp_open_seq; /* open sequences per exchange */ __u8 _cp_resv2[2]; /* reserved */ }; /* * cp_class flags. */ #define FC_CPC_VALID 0x8000 /* class valid */ #define FC_CPC_IMIX 0x4000 /* intermix mode */ #define FC_CPC_SEQ 0x0800 /* sequential delivery */ #define FC_CPC_CAMP 0x0200 /* camp-on */ #define FC_CPC_PRI 0x0080 /* priority */ /* * cp_init flags. * (TBD: not all flags defined here). */ #define FC_CPI_CSYN 0x0010 /* clock synch. capable */ /* * cp_recip flags. */ #define FC_CPR_CSYN 0x0008 /* clock synch. capable */ /* * NFC_ELS_FLOGI: Fabric login request. * NFC_ELS_PLOGI: Port login request (same format). */ struct fc_els_flogi { __u8 fl_cmd; /* command */ __u8 _fl_resvd[3]; /* must be zero */ struct fc_els_csp fl_csp; /* common service parameters */ __be64 fl_wwpn; /* port name */ __be64 fl_wwnn; /* node name */ struct fc_els_cssp fl_cssp[4]; /* class 1-4 service parameters */ __u8 fl_vend[16]; /* vendor version level */ } __attribute__((__packed__)); /* * Process login service parameter page. */ struct fc_els_spp { __u8 spp_type; /* type code or common service params */ __u8 spp_type_ext; /* type code extension */ __u8 spp_flags; __u8 _spp_resvd; __be32 spp_orig_pa; /* originator process associator */ __be32 spp_resp_pa; /* responder process associator */ __be32 spp_params; /* service parameters */ }; /* * spp_flags. */ #define FC_SPP_OPA_VAL 0x80 /* originator proc. assoc. valid */ #define FC_SPP_RPA_VAL 0x40 /* responder proc. assoc. valid */ #define FC_SPP_EST_IMG_PAIR 0x20 /* establish image pair */ #define FC_SPP_RESP_MASK 0x0f /* mask for response code (below) */ /* * SPP response code in spp_flags - lower 4 bits. */ enum fc_els_spp_resp { FC_SPP_RESP_ACK = 1, /* request executed */ FC_SPP_RESP_RES = 2, /* unable due to lack of resources */ FC_SPP_RESP_INIT = 3, /* initialization not complete */ FC_SPP_RESP_NO_PA = 4, /* unknown process associator */ FC_SPP_RESP_CONF = 5, /* configuration precludes image pair */ FC_SPP_RESP_COND = 6, /* request completed conditionally */ FC_SPP_RESP_MULT = 7, /* unable to handle multiple SPPs */ FC_SPP_RESP_INVL = 8, /* SPP is invalid */ }; /* * ELS_RRQ - Reinstate Recovery Qualifier */ struct fc_els_rrq { __u8 rrq_cmd; /* command (0x12) */ __u8 rrq_zero[3]; /* specified as zero - part of cmd */ __u8 rrq_resvd; /* reserved */ __u8 rrq_s_id[3]; /* originator FID */ __be16 rrq_ox_id; /* originator exchange ID */ __be16 rrq_rx_id; /* responders exchange ID */ }; /* * ELS_REC - Read exchange concise. */ struct fc_els_rec { __u8 rec_cmd; /* command (0x13) */ __u8 rec_zero[3]; /* specified as zero - part of cmd */ __u8 rec_resvd; /* reserved */ __u8 rec_s_id[3]; /* originator FID */ __be16 rec_ox_id; /* originator exchange ID */ __be16 rec_rx_id; /* responders exchange ID */ }; /* * ELS_REC LS_ACC payload. */ struct fc_els_rec_acc { __u8 reca_cmd; /* accept (0x02) */ __u8 reca_zero[3]; /* specified as zero - part of cmd */ __be16 reca_ox_id; /* originator exchange ID */ __be16 reca_rx_id; /* responders exchange ID */ __u8 reca_resvd1; /* reserved */ __u8 reca_ofid[3]; /* originator FID */ __u8 reca_resvd2; /* reserved */ __u8 reca_rfid[3]; /* responder FID */ __be32 reca_fc4value; /* FC4 value */ __be32 reca_e_stat; /* ESB (exchange status block) status */ }; /* * ELS_PRLI - Process login request and response. */ struct fc_els_prli { __u8 prli_cmd; /* command */ __u8 prli_spp_len; /* length of each serv. parm. page */ __be16 prli_len; /* length of entire payload */ /* service parameter pages follow */ }; /* * ELS_PRLO - Process logout request and response. */ struct fc_els_prlo { __u8 prlo_cmd; /* command */ __u8 prlo_obs; /* obsolete, but shall be set to 10h */ __be16 prlo_len; /* payload length */ }; /* * ELS_ADISC payload */ struct fc_els_adisc { __u8 adisc_cmd; __u8 adisc_resv[3]; __u8 adisc_resv1; __u8 adisc_hard_addr[3]; __be64 adisc_wwpn; __be64 adisc_wwnn; __u8 adisc_resv2; __u8 adisc_port_id[3]; } __attribute__((__packed__)); /* * ELS_LOGO - process or fabric logout. */ struct fc_els_logo { __u8 fl_cmd; /* command code */ __u8 fl_zero[3]; /* specified as zero - part of cmd */ __u8 fl_resvd; /* reserved */ __u8 fl_n_port_id[3];/* N port ID */ __be64 fl_n_port_wwn; /* port name */ }; /* * ELS_RTV - read timeout value. */ struct fc_els_rtv { __u8 rtv_cmd; /* command code 0x0e */ __u8 rtv_zero[3]; /* specified as zero - part of cmd */ }; /* * LS_ACC for ELS_RTV - read timeout value. */ struct fc_els_rtv_acc { __u8 rtv_cmd; /* command code 0x02 */ __u8 rtv_zero[3]; /* specified as zero - part of cmd */ __be32 rtv_r_a_tov; /* resource allocation timeout value */ __be32 rtv_e_d_tov; /* error detection timeout value */ __be32 rtv_toq; /* timeout qualifier (see below) */ }; /* * rtv_toq bits. */ #define FC_ELS_RTV_EDRES (1 << 26) /* E_D_TOV resolution is nS else mS */ #define FC_ELS_RTV_RTTOV (1 << 19) /* R_T_TOV is 100 uS else 100 mS */ /* * ELS_SCR - state change registration payload. */ struct fc_els_scr { __u8 scr_cmd; /* command code */ __u8 scr_resv[6]; /* reserved */ __u8 scr_reg_func; /* registration function (see below) */ }; enum fc_els_scr_func { ELS_SCRF_FAB = 1, /* fabric-detected registration */ ELS_SCRF_NPORT = 2, /* Nx_Port-detected registration */ ELS_SCRF_FULL = 3, /* full registration */ ELS_SCRF_CLEAR = 255, /* remove any current registrations */ }; /* * ELS_RSCN - registered state change notification payload. */ struct fc_els_rscn { __u8 rscn_cmd; /* RSCN opcode (0x61) */ __u8 rscn_page_len; /* page length (4) */ __be16 rscn_plen; /* payload length including this word */ /* followed by 4-byte generic affected Port_ID pages */ }; struct fc_els_rscn_page { __u8 rscn_page_flags; /* event and address format */ __u8 rscn_fid[3]; /* fabric ID */ }; #define ELS_RSCN_EV_QUAL_BIT 2 /* shift count for event qualifier */ #define ELS_RSCN_EV_QUAL_MASK 0xf /* mask for event qualifier */ #define ELS_RSCN_ADDR_FMT_BIT 0 /* shift count for address format */ #define ELS_RSCN_ADDR_FMT_MASK 0x3 /* mask for address format */ enum fc_els_rscn_ev_qual { ELS_EV_QUAL_NONE = 0, /* unspecified */ ELS_EV_QUAL_NS_OBJ = 1, /* changed name server object */ ELS_EV_QUAL_PORT_ATTR = 2, /* changed port attribute */ ELS_EV_QUAL_SERV_OBJ = 3, /* changed service object */ ELS_EV_QUAL_SW_CONFIG = 4, /* changed switch configuration */ ELS_EV_QUAL_REM_OBJ = 5, /* removed object */ }; enum fc_els_rscn_addr_fmt { ELS_ADDR_FMT_PORT = 0, /* rscn_fid is a port address */ ELS_ADDR_FMT_AREA = 1, /* rscn_fid is a area address */ ELS_ADDR_FMT_DOM = 2, /* rscn_fid is a domain address */ ELS_ADDR_FMT_FAB = 3, /* anything on fabric may have changed */ }; /* * ELS_RNID - request Node ID. */ struct fc_els_rnid { __u8 rnid_cmd; /* RNID opcode (0x78) */ __u8 rnid_resv[3]; /* reserved */ __u8 rnid_fmt; /* data format */ __u8 rnid_resv2[3]; /* reserved */ }; /* * Node Identification Data formats (rnid_fmt) */ enum fc_els_rnid_fmt { ELS_RNIDF_NONE = 0, /* no specific identification data */ ELS_RNIDF_GEN = 0xdf, /* general topology discovery format */ }; /* * ELS_RNID response. */ struct fc_els_rnid_resp { __u8 rnid_cmd; /* response code (LS_ACC) */ __u8 rnid_resv[3]; /* reserved */ __u8 rnid_fmt; /* data format */ __u8 rnid_cid_len; /* common ID data length */ __u8 rnid_resv2; /* reserved */ __u8 rnid_sid_len; /* specific ID data length */ }; struct fc_els_rnid_cid { __be64 rnid_wwpn; /* N port name */ __be64 rnid_wwnn; /* node name */ }; struct fc_els_rnid_gen { __u8 rnid_vend_id[16]; /* vendor-unique ID */ __be32 rnid_atype; /* associated type (see below) */ __be32 rnid_phys_port; /* physical port number */ __be32 rnid_att_nodes; /* number of attached nodes */ __u8 rnid_node_mgmt; /* node management (see below) */ __u8 rnid_ip_ver; /* IP version (see below) */ __be16 rnid_prot_port; /* UDP / TCP port number */ __be32 rnid_ip_addr[4]; /* IP address */ __u8 rnid_resvd[2]; /* reserved */ __be16 rnid_vend_spec; /* vendor-specific field */ }; enum fc_els_rnid_atype { ELS_RNIDA_UNK = 0x01, /* unknown */ ELS_RNIDA_OTHER = 0x02, /* none of the following */ ELS_RNIDA_HUB = 0x03, ELS_RNIDA_SWITCH = 0x04, ELS_RNIDA_GATEWAY = 0x05, ELS_RNIDA_CONV = 0x06, /* Obsolete, do not use this value */ ELS_RNIDA_HBA = 0x07, /* Obsolete, do not use this value */ ELS_RNIDA_PROXY = 0x08, /* Obsolete, do not use this value */ ELS_RNIDA_STORAGE = 0x09, ELS_RNIDA_HOST = 0x0a, ELS_RNIDA_SUBSYS = 0x0b, /* storage subsystem (e.g., RAID) */ ELS_RNIDA_ACCESS = 0x0e, /* access device (e.g. media changer) */ ELS_RNIDA_NAS = 0x11, /* NAS server */ ELS_RNIDA_BRIDGE = 0x12, /* bridge */ ELS_RNIDA_VIRT = 0x13, /* virtualization device */ ELS_RNIDA_MF = 0xff, /* multifunction device (bits below) */ ELS_RNIDA_MF_HUB = 1UL << 31, /* hub */ ELS_RNIDA_MF_SW = 1UL << 30, /* switch */ ELS_RNIDA_MF_GW = 1UL << 29, /* gateway */ ELS_RNIDA_MF_ST = 1UL << 28, /* storage */ ELS_RNIDA_MF_HOST = 1UL << 27, /* host */ ELS_RNIDA_MF_SUB = 1UL << 26, /* storage subsystem */ ELS_RNIDA_MF_ACC = 1UL << 25, /* storage access dev */ ELS_RNIDA_MF_WDM = 1UL << 24, /* wavelength division mux */ ELS_RNIDA_MF_NAS = 1UL << 23, /* NAS server */ ELS_RNIDA_MF_BR = 1UL << 22, /* bridge */ ELS_RNIDA_MF_VIRT = 1UL << 21, /* virtualization device */ }; enum fc_els_rnid_mgmt { ELS_RNIDM_SNMP = 0, ELS_RNIDM_TELNET = 1, ELS_RNIDM_HTTP = 2, ELS_RNIDM_HTTPS = 3, ELS_RNIDM_XML = 4, /* HTTP + XML */ }; enum fc_els_rnid_ipver { ELS_RNIDIP_NONE = 0, /* no IP support or node mgmt. */ ELS_RNIDIP_V4 = 1, /* IPv4 */ ELS_RNIDIP_V6 = 2, /* IPv6 */ }; /* * ELS RPL - Read Port List. */ struct fc_els_rpl { __u8 rpl_cmd; /* command */ __u8 rpl_resv[5]; /* reserved - must be zero */ __be16 rpl_max_size; /* maximum response size or zero */ __u8 rpl_resv1; /* reserved - must be zero */ __u8 rpl_index[3]; /* starting index */ }; /* * Port number block in RPL response. */ struct fc_els_pnb { __be32 pnb_phys_pn; /* physical port number */ __u8 pnb_resv; /* reserved */ __u8 pnb_port_id[3]; /* port ID */ __be64 pnb_wwpn; /* port name */ }; /* * RPL LS_ACC response. */ struct fc_els_rpl_resp { __u8 rpl_cmd; /* ELS_LS_ACC */ __u8 rpl_resv1; /* reserved - must be zero */ __be16 rpl_plen; /* payload length */ __u8 rpl_resv2; /* reserved - must be zero */ __u8 rpl_llen[3]; /* list length */ __u8 rpl_resv3; /* reserved - must be zero */ __u8 rpl_index[3]; /* starting index */ struct fc_els_pnb rpl_pnb[1]; /* variable number of PNBs */ }; /* * Link Error Status Block. */ struct fc_els_lesb { __be32 lesb_link_fail; /* link failure count */ __be32 lesb_sync_loss; /* loss of synchronization count */ __be32 lesb_sig_loss; /* loss of signal count */ __be32 lesb_prim_err; /* primitive sequence error count */ __be32 lesb_inv_word; /* invalid transmission word count */ __be32 lesb_inv_crc; /* invalid CRC count */ }; /* * ELS RPS - Read Port Status Block request. */ struct fc_els_rps { __u8 rps_cmd; /* command */ __u8 rps_resv[2]; /* reserved - must be zero */ __u8 rps_flag; /* flag - see below */ __be64 rps_port_spec; /* port selection */ }; enum fc_els_rps_flag { FC_ELS_RPS_DID = 0x00, /* port identified by D_ID of req. */ FC_ELS_RPS_PPN = 0x01, /* port_spec is physical port number */ FC_ELS_RPS_WWPN = 0x02, /* port_spec is port WWN */ }; /* * ELS RPS LS_ACC response. */ struct fc_els_rps_resp { __u8 rps_cmd; /* command - LS_ACC */ __u8 rps_resv[2]; /* reserved - must be zero */ __u8 rps_flag; /* flag - see below */ __u8 rps_resv2[2]; /* reserved */ __be16 rps_status; /* port status - see below */ struct fc_els_lesb rps_lesb; /* link error status block */ }; enum fc_els_rps_resp_flag { FC_ELS_RPS_LPEV = 0x01, /* L_port extension valid */ }; enum fc_els_rps_resp_status { FC_ELS_RPS_PTP = 1 << 5, /* point-to-point connection */ FC_ELS_RPS_LOOP = 1 << 4, /* loop mode */ FC_ELS_RPS_FAB = 1 << 3, /* fabric present */ FC_ELS_RPS_NO_SIG = 1 << 2, /* loss of signal */ FC_ELS_RPS_NO_SYNC = 1 << 1, /* loss of synchronization */ FC_ELS_RPS_RESET = 1 << 0, /* in link reset protocol */ }; /* * ELS LIRR - Link Incident Record Registration request. */ struct fc_els_lirr { __u8 lirr_cmd; /* command */ __u8 lirr_resv[3]; /* reserved - must be zero */ __u8 lirr_func; /* registration function */ __u8 lirr_fmt; /* FC-4 type of RLIR requested */ __u8 lirr_resv2[2]; /* reserved - must be zero */ }; enum fc_els_lirr_func { ELS_LIRR_SET_COND = 0x01, /* set - conditionally receive */ ELS_LIRR_SET_UNCOND = 0x02, /* set - unconditionally receive */ ELS_LIRR_CLEAR = 0xff /* clear registration */ }; /* * ELS SRL - Scan Remote Loop request. */ struct fc_els_srl { __u8 srl_cmd; /* command */ __u8 srl_resv[3]; /* reserved - must be zero */ __u8 srl_flag; /* flag - see below */ __u8 srl_flag_param[3]; /* flag parameter */ }; enum fc_els_srl_flag { FC_ELS_SRL_ALL = 0x00, /* scan all FL ports */ FC_ELS_SRL_ONE = 0x01, /* scan specified loop */ FC_ELS_SRL_EN_PER = 0x02, /* enable periodic scanning (param) */ FC_ELS_SRL_DIS_PER = 0x03, /* disable periodic scanning */ }; /* * ELS RLS - Read Link Error Status Block request. */ struct fc_els_rls { __u8 rls_cmd; /* command */ __u8 rls_resv[4]; /* reserved - must be zero */ __u8 rls_port_id[3]; /* port ID */ }; /* * ELS RLS LS_ACC Response. */ struct fc_els_rls_resp { __u8 rls_cmd; /* ELS_LS_ACC */ __u8 rls_resv[3]; /* reserved - must be zero */ struct fc_els_lesb rls_lesb; /* link error status block */ }; /* * ELS RLIR - Registered Link Incident Report. * This is followed by the CLIR and the CLID, described below. */ struct fc_els_rlir { __u8 rlir_cmd; /* command */ __u8 rlir_resv[3]; /* reserved - must be zero */ __u8 rlir_fmt; /* format (FC4-type if type specific) */ __u8 rlir_clr_len; /* common link incident record length */ __u8 rlir_cld_len; /* common link incident desc. length */ __u8 rlir_slr_len; /* spec. link incident record length */ }; /* * CLIR - Common Link Incident Record Data. - Sent via RLIR. */ struct fc_els_clir { __be64 clir_wwpn; /* incident port name */ __be64 clir_wwnn; /* incident port node name */ __u8 clir_port_type; /* incident port type */ __u8 clir_port_id[3]; /* incident port ID */ __be64 clir_conn_wwpn; /* connected port name */ __be64 clir_conn_wwnn; /* connected node name */ __be64 clir_fab_name; /* fabric name */ __be32 clir_phys_port; /* physical port number */ __be32 clir_trans_id; /* transaction ID */ __u8 clir_resv[3]; /* reserved */ __u8 clir_ts_fmt; /* time stamp format */ __be64 clir_timestamp; /* time stamp */ }; /* * CLIR clir_ts_fmt - time stamp format values. */ enum fc_els_clir_ts_fmt { ELS_CLIR_TS_UNKNOWN = 0, /* time stamp field unknown */ ELS_CLIR_TS_SEC_FRAC = 1, /* time in seconds and fractions */ ELS_CLIR_TS_CSU = 2, /* time in clock synch update format */ }; /* * Common Link Incident Descriptor - sent via RLIR. */ struct fc_els_clid { __u8 clid_iq; /* incident qualifier flags */ __u8 clid_ic; /* incident code */ __be16 clid_epai; /* domain/area of ISL */ }; /* * CLID incident qualifier flags. */ enum fc_els_clid_iq { ELS_CLID_SWITCH = 0x20, /* incident port is a switch node */ ELS_CLID_E_PORT = 0x10, /* incident is an ISL (E) port */ ELS_CLID_SEV_MASK = 0x0c, /* severity 2-bit field mask */ ELS_CLID_SEV_INFO = 0x00, /* report is informational */ ELS_CLID_SEV_INOP = 0x08, /* link not operational */ ELS_CLID_SEV_DEG = 0x04, /* link degraded but operational */ ELS_CLID_LASER = 0x02, /* subassembly is a laser */ ELS_CLID_FRU = 0x01, /* format can identify a FRU */ }; /* * CLID incident code. */ enum fc_els_clid_ic { ELS_CLID_IC_IMPL = 1, /* implicit incident */ ELS_CLID_IC_BER = 2, /* bit-error-rate threshold exceeded */ ELS_CLID_IC_LOS = 3, /* loss of synch or signal */ ELS_CLID_IC_NOS = 4, /* non-operational primitive sequence */ ELS_CLID_IC_PST = 5, /* primitive sequence timeout */ ELS_CLID_IC_INVAL = 6, /* invalid primitive sequence */ ELS_CLID_IC_LOOP_TO = 7, /* loop initialization time out */ ELS_CLID_IC_LIP = 8, /* receiving LIP */ }; /* * Link Integrity event types */ enum fc_fpin_li_event_types { FPIN_LI_UNKNOWN = 0x0, FPIN_LI_LINK_FAILURE = 0x1, FPIN_LI_LOSS_OF_SYNC = 0x2, FPIN_LI_LOSS_OF_SIG = 0x3, FPIN_LI_PRIM_SEQ_ERR = 0x4, FPIN_LI_INVALID_TX_WD = 0x5, FPIN_LI_INVALID_CRC = 0x6, FPIN_LI_DEVICE_SPEC = 0xF, }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_FPIN_LI_EVT_TYPES_INIT { \ { FPIN_LI_UNKNOWN, "Unknown" }, \ { FPIN_LI_LINK_FAILURE, "Link Failure" }, \ { FPIN_LI_LOSS_OF_SYNC, "Loss of Synchronization" }, \ { FPIN_LI_LOSS_OF_SIG, "Loss of Signal" }, \ { FPIN_LI_PRIM_SEQ_ERR, "Primitive Sequence Protocol Error" }, \ { FPIN_LI_INVALID_TX_WD, "Invalid Transmission Word" }, \ { FPIN_LI_INVALID_CRC, "Invalid CRC" }, \ { FPIN_LI_DEVICE_SPEC, "Device Specific" }, \ } /* * Delivery event types */ enum fc_fpin_deli_event_types { FPIN_DELI_UNKNOWN = 0x0, FPIN_DELI_TIMEOUT = 0x1, FPIN_DELI_UNABLE_TO_ROUTE = 0x2, FPIN_DELI_DEVICE_SPEC = 0xF, }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_FPIN_DELI_EVT_TYPES_INIT { \ { FPIN_DELI_UNKNOWN, "Unknown" }, \ { FPIN_DELI_TIMEOUT, "Timeout" }, \ { FPIN_DELI_UNABLE_TO_ROUTE, "Unable to Route" }, \ { FPIN_DELI_DEVICE_SPEC, "Device Specific" }, \ } /* * Congestion event types */ enum fc_fpin_congn_event_types { FPIN_CONGN_CLEAR = 0x0, FPIN_CONGN_LOST_CREDIT = 0x1, FPIN_CONGN_CREDIT_STALL = 0x2, FPIN_CONGN_OVERSUBSCRIPTION = 0x3, FPIN_CONGN_DEVICE_SPEC = 0xF, }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_FPIN_CONGN_EVT_TYPES_INIT { \ { FPIN_CONGN_CLEAR, "Clear" }, \ { FPIN_CONGN_LOST_CREDIT, "Lost Credit" }, \ { FPIN_CONGN_CREDIT_STALL, "Credit Stall" }, \ { FPIN_CONGN_OVERSUBSCRIPTION, "Oversubscription" }, \ { FPIN_CONGN_DEVICE_SPEC, "Device Specific" }, \ } enum fc_fpin_congn_severity_types { FPIN_CONGN_SEVERITY_WARNING = 0xF1, FPIN_CONGN_SEVERITY_ERROR = 0xF7, }; /* * Link Integrity Notification Descriptor */ struct fc_fn_li_desc { __be32 desc_tag; /* Descriptor Tag (0x00020001) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __be64 detecting_wwpn; /* Port Name that detected event */ __be64 attached_wwpn; /* Port Name of device attached to * detecting Port Name */ __be16 event_type; /* see enum fc_fpin_li_event_types */ __be16 event_modifier; /* Implementation specific value * describing the event type */ __be32 event_threshold;/* duration in ms of the link * integrity detection cycle */ __be32 event_count; /* minimum number of event * occurrences during the event * threshold to caause the LI event */ __be32 pname_count; /* number of portname_list elements */ __be64 pname_list[0]; /* list of N_Port_Names accessible * through the attached port */ }; /* * Delivery Notification Descriptor */ struct fc_fn_deli_desc { __be32 desc_tag; /* Descriptor Tag (0x00020002) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __be64 detecting_wwpn; /* Port Name that detected event */ __be64 attached_wwpn; /* Port Name of device attached to * detecting Port Name */ __be32 deli_reason_code;/* see enum fc_fpin_deli_event_types */ }; /* * Peer Congestion Notification Descriptor */ struct fc_fn_peer_congn_desc { __be32 desc_tag; /* Descriptor Tag (0x00020003) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __be64 detecting_wwpn; /* Port Name that detected event */ __be64 attached_wwpn; /* Port Name of device attached to * detecting Port Name */ __be16 event_type; /* see enum fc_fpin_congn_event_types */ __be16 event_modifier; /* Implementation specific value * describing the event type */ __be32 event_period; /* duration (ms) of the detected * congestion event */ __be32 pname_count; /* number of portname_list elements */ __be64 pname_list[0]; /* list of N_Port_Names accessible * through the attached port */ }; /* * Congestion Notification Descriptor */ struct fc_fn_congn_desc { __be32 desc_tag; /* Descriptor Tag (0x00020004) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __be16 event_type; /* see enum fc_fpin_congn_event_types */ __be16 event_modifier; /* Implementation specific value * describing the event type */ __be32 event_period; /* duration (ms) of the detected * congestion event */ __u8 severity; /* command */ __u8 resv[3]; /* reserved - must be zero */ }; /* * ELS_FPIN - Fabric Performance Impact Notification */ struct fc_els_fpin { __u8 fpin_cmd; /* command (0x16) */ __u8 fpin_zero[3]; /* specified as zero - part of cmd */ __be32 desc_len; /* Length of Descriptor List (in bytes). * Size of ELS excluding fpin_cmd, * fpin_zero and desc_len fields. */ struct fc_tlv_desc fpin_desc[0]; /* Descriptor list */ }; /* Diagnostic Function Descriptor - FPIN Registration */ struct fc_df_desc_fpin_reg { __be32 desc_tag; /* FPIN Registration (0x00030001) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. */ __be32 count; /* Number of desc_tags elements */ __be32 desc_tags[0]; /* Array of Descriptor Tags. * Each tag indicates a function * supported by the N_Port (request) * or by the N_Port and Fabric * Controller (reply; may be a subset * of the request). * See ELS_FN_DTAG_xxx for tag values. */ }; /* * ELS_RDF - Register Diagnostic Functions */ struct fc_els_rdf { __u8 fpin_cmd; /* command (0x19) */ __u8 fpin_zero[3]; /* specified as zero - part of cmd */ __be32 desc_len; /* Length of Descriptor List (in bytes). * Size of ELS excluding fpin_cmd, * fpin_zero and desc_len fields. */ struct fc_tlv_desc desc[0]; /* Descriptor list */ }; /* * ELS RDF LS_ACC Response. */ struct fc_els_rdf_resp { struct fc_els_ls_acc acc_hdr; __be32 desc_list_len; /* Length of response (in * bytes). Excludes acc_hdr * and desc_list_len fields. */ struct fc_els_lsri_desc lsri; struct fc_tlv_desc desc[0]; /* Supported Descriptor list */ }; /* * Diagnostic Capability Descriptors for EDC ELS */ /* * Diagnostic: Link Fault Capability Descriptor */ struct fc_diag_lnkflt_desc { __be32 desc_tag; /* Descriptor Tag (0x0001000D) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. * 12 bytes */ __be32 degrade_activate_threshold; __be32 degrade_deactivate_threshold; __be32 fec_degrade_interval; }; enum fc_edc_cg_signal_cap_types { /* Note: Capability: bits 31:4 Rsvd; bits 3:0 are capabilities */ EDC_CG_SIG_NOTSUPPORTED = 0x00, /* neither supported */ EDC_CG_SIG_WARN_ONLY = 0x01, EDC_CG_SIG_WARN_ALARM = 0x02, /* both supported */ }; /* * Initializer useful for decoding table. * Please keep this in sync with the above definitions. */ #define FC_EDC_CG_SIGNAL_CAP_TYPES_INIT { \ { EDC_CG_SIG_NOTSUPPORTED, "Signaling Not Supported" }, \ { EDC_CG_SIG_WARN_ONLY, "Warning Signal" }, \ { EDC_CG_SIG_WARN_ALARM, "Warning and Alarm Signals" }, \ } enum fc_diag_cg_sig_freq_types { EDC_CG_SIGFREQ_CNT_MIN = 1, /* Min Frequency Count */ EDC_CG_SIGFREQ_CNT_MAX = 999, /* Max Frequency Count */ EDC_CG_SIGFREQ_SEC = 0x1, /* Units: seconds */ EDC_CG_SIGFREQ_MSEC = 0x2, /* Units: milliseconds */ }; struct fc_diag_cg_sig_freq { __be16 count; /* Time between signals * note: upper 6 bits rsvd */ __be16 units; /* Time unit for count * note: upper 12 bits rsvd */ }; /* * Diagnostic: Congestion Signaling Capability Descriptor */ struct fc_diag_cg_sig_desc { __be32 desc_tag; /* Descriptor Tag (0x0001000F) */ __be32 desc_len; /* Length of Descriptor (in bytes). * Size of descriptor excluding * desc_tag and desc_len fields. * 16 bytes */ __be32 xmt_signal_capability; struct fc_diag_cg_sig_freq xmt_signal_frequency; __be32 rcv_signal_capability; struct fc_diag_cg_sig_freq rcv_signal_frequency; }; /* * ELS_EDC - Exchange Diagnostic Capabilities */ struct fc_els_edc { __u8 edc_cmd; /* command (0x17) */ __u8 edc_zero[3]; /* specified as zero - part of cmd */ __be32 desc_len; /* Length of Descriptor List (in bytes). * Size of ELS excluding edc_cmd, * edc_zero and desc_len fields. */ struct fc_tlv_desc desc[0]; /* Diagnostic Descriptor list */ }; /* * ELS EDC LS_ACC Response. */ struct fc_els_edc_resp { struct fc_els_ls_acc acc_hdr; __be32 desc_list_len; /* Length of response (in * bytes). Excludes acc_hdr * and desc_list_len fields. */ struct fc_els_lsri_desc lsri; struct fc_tlv_desc desc[0]; /* Supported Diagnostic Descriptor list */ }; #endif /* _FC_ELS_H_ */ scsi/fc/fc_ns.h000064400000011565152640040160007344 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * Copyright(c) 2007 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. * * Maintained at www.Open-FCoE.org */ #ifndef _FC_NS_H_ #define _FC_NS_H_ #include /* * Fibre Channel Services - Name Service (dNS) * From T11.org FC-GS-2 Rev 5.3 November 1998. */ /* * Common-transport sub-type for Name Server. */ #define FC_NS_SUBTYPE 2 /* fs_ct_hdr.ct_fs_subtype */ /* * Name server Requests. * Note: this is an incomplete list, some unused requests are omitted. */ enum fc_ns_req { FC_NS_GA_NXT = 0x0100, /* get all next */ FC_NS_GI_A = 0x0101, /* get identifiers - scope */ FC_NS_GPN_ID = 0x0112, /* get port name by ID */ FC_NS_GNN_ID = 0x0113, /* get node name by ID */ FC_NS_GSPN_ID = 0x0118, /* get symbolic port name */ FC_NS_GID_PN = 0x0121, /* get ID for port name */ FC_NS_GID_NN = 0x0131, /* get IDs for node name */ FC_NS_GID_FT = 0x0171, /* get IDs by FC4 type */ FC_NS_GPN_FT = 0x0172, /* get port names by FC4 type */ FC_NS_GID_PT = 0x01a1, /* get IDs by port type */ FC_NS_RPN_ID = 0x0212, /* reg port name for ID */ FC_NS_RNN_ID = 0x0213, /* reg node name for ID */ FC_NS_RFT_ID = 0x0217, /* reg FC4 type for ID */ FC_NS_RSPN_ID = 0x0218, /* reg symbolic port name */ FC_NS_RFF_ID = 0x021f, /* reg FC4 Features for ID */ FC_NS_RSNN_NN = 0x0239, /* reg symbolic node name */ }; /* * Port type values. */ enum fc_ns_pt { FC_NS_UNID_PORT = 0x00, /* unidentified */ FC_NS_N_PORT = 0x01, /* N port */ FC_NS_NL_PORT = 0x02, /* NL port */ FC_NS_FNL_PORT = 0x03, /* F/NL port */ FC_NS_NX_PORT = 0x7f, /* Nx port */ FC_NS_F_PORT = 0x81, /* F port */ FC_NS_FL_PORT = 0x82, /* FL port */ FC_NS_E_PORT = 0x84, /* E port */ FC_NS_B_PORT = 0x85, /* B port */ }; /* * Port type object. */ struct fc_ns_pt_obj { __u8 pt_type; }; /* * Port ID object */ struct fc_ns_fid { __u8 fp_flags; /* flags for responses only */ __u8 fp_fid[3]; }; /* * fp_flags in port ID object, for responses only. */ #define FC_NS_FID_LAST 0x80 /* last object */ /* * FC4-types object. */ #define FC_NS_TYPES 256 /* number of possible FC-4 types */ #define FC_NS_BPW 32 /* bits per word in bitmap */ struct fc_ns_fts { __be32 ff_type_map[FC_NS_TYPES / FC_NS_BPW]; /* bitmap of FC-4 types */ }; /* * FC4-features object. */ struct fc_ns_ff { __be32 fd_feat[FC_NS_TYPES * 4 / FC_NS_BPW]; /* 4-bits per FC-type */ }; /* * GID_PT request. */ struct fc_ns_gid_pt { __u8 fn_pt_type; __u8 fn_domain_id_scope; __u8 fn_area_id_scope; __u8 fn_resvd; }; /* * GID_FT or GPN_FT request. */ struct fc_ns_gid_ft { __u8 fn_resvd; __u8 fn_domain_id_scope; __u8 fn_area_id_scope; __u8 fn_fc4_type; }; /* * GPN_FT response. */ struct fc_gpn_ft_resp { __u8 fp_flags; /* see fp_flags definitions above */ __u8 fp_fid[3]; /* port ID */ __be32 fp_resvd; __be64 fp_wwpn; /* port name */ }; /* * GID_PN request */ struct fc_ns_gid_pn { __be64 fn_wwpn; /* port name */ }; /* * GID_PN response or GSPN_ID request */ struct fc_gid_pn_resp { __u8 fp_resvd; __u8 fp_fid[3]; /* port ID */ }; /* * GSPN_ID response */ struct fc_gspn_resp { __u8 fp_name_len; char fp_name[]; }; /* * RFT_ID request - register FC-4 types for ID. */ struct fc_ns_rft_id { struct fc_ns_fid fr_fid; /* port ID object */ struct fc_ns_fts fr_fts; /* FC-4 types object */ }; /* * RPN_ID request - register port name for ID. * RNN_ID request - register node name for ID. */ struct fc_ns_rn_id { struct fc_ns_fid fr_fid; /* port ID object */ __be64 fr_wwn; /* node name or port name */ } __attribute__((__packed__)); /* * RSNN_NN request - register symbolic node name */ struct fc_ns_rsnn { __be64 fr_wwn; /* node name */ __u8 fr_name_len; char fr_name[]; } __attribute__((__packed__)); /* * RSPN_ID request - register symbolic port name */ struct fc_ns_rspn { struct fc_ns_fid fr_fid; /* port ID object */ __u8 fr_name_len; char fr_name[]; } __attribute__((__packed__)); /* * RFF_ID request - register FC-4 Features for ID. */ struct fc_ns_rff_id { struct fc_ns_fid fr_fid; /* port ID object */ __u8 fr_resvd[2]; __u8 fr_feat; /* FC-4 Feature bits */ __u8 fr_type; /* FC-4 type */ } __attribute__((__packed__)); #endif /* _FC_NS_H_ */ scsi/fc/fc_gs.h000064400000005517152640040160007335 0ustar00/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ /* * Copyright(c) 2007 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. * * Maintained at www.Open-FCoE.org */ #ifndef _FC_GS_H_ #define _FC_GS_H_ #include /* * Fibre Channel Services - Common Transport. * From T11.org FC-GS-2 Rev 5.3 November 1998. */ struct fc_ct_hdr { __u8 ct_rev; /* revision */ __u8 ct_in_id[3]; /* N_Port ID of original requestor */ __u8 ct_fs_type; /* type of fibre channel service */ __u8 ct_fs_subtype; /* subtype */ __u8 ct_options; __u8 _ct_resvd1; __be16 ct_cmd; /* command / response code */ __be16 ct_mr_size; /* maximum / residual size */ __u8 _ct_resvd2; __u8 ct_reason; /* reject reason */ __u8 ct_explan; /* reason code explanation */ __u8 ct_vendor; /* vendor unique data */ }; #define FC_CT_HDR_LEN 16 /* expected sizeof (struct fc_ct_hdr) */ enum fc_ct_rev { FC_CT_REV = 1 /* common transport revision */ }; /* * ct_fs_type values. */ enum fc_ct_fs_type { FC_FST_ALIAS = 0xf8, /* alias service */ FC_FST_MGMT = 0xfa, /* management service */ FC_FST_TIME = 0xfb, /* time service */ FC_FST_DIR = 0xfc, /* directory service */ }; /* * ct_cmd: Command / response codes */ enum fc_ct_cmd { FC_FS_RJT = 0x8001, /* reject */ FC_FS_ACC = 0x8002, /* accept */ }; /* * FS_RJT reason codes. */ enum fc_ct_reason { FC_FS_RJT_CMD = 0x01, /* invalid command code */ FC_FS_RJT_VER = 0x02, /* invalid version level */ FC_FS_RJT_LOG = 0x03, /* logical error */ FC_FS_RJT_IUSIZ = 0x04, /* invalid IU size */ FC_FS_RJT_BSY = 0x05, /* logical busy */ FC_FS_RJT_PROTO = 0x07, /* protocol error */ FC_FS_RJT_UNABL = 0x09, /* unable to perform command request */ FC_FS_RJT_UNSUP = 0x0b, /* command not supported */ }; /* * FS_RJT reason code explanations. */ enum fc_ct_explan { FC_FS_EXP_NONE = 0x00, /* no additional explanation */ FC_FS_EXP_PID = 0x01, /* port ID not registered */ FC_FS_EXP_PNAM = 0x02, /* port name not registered */ FC_FS_EXP_NNAM = 0x03, /* node name not registered */ FC_FS_EXP_COS = 0x04, /* class of service not registered */ FC_FS_EXP_FTNR = 0x07, /* FC-4 types not registered */ /* definitions not complete */ }; #endif /* _FC_GS_H_ */ scsi/scsi_bsg_mpi3mr.h000064400000036247152640040160010753 0ustar00/* SPDX-License-Identifier: GPL-2.0-or-later WITH Linux-syscall-note */ /* * Driver for Broadcom MPI3 Storage Controllers * * Copyright (C) 2017-2022 Broadcom Inc. * (mailto: mpi3mr-linuxdrv.pdl@broadcom.com) * */ #ifndef SCSI_BSG_MPI3MR_H_INCLUDED #define SCSI_BSG_MPI3MR_H_INCLUDED #include /* Definitions for BSG commands */ #define MPI3MR_IOCTL_VERSION 0x06 #define MPI3MR_APP_DEFAULT_TIMEOUT (60) /*seconds*/ #define MPI3MR_BSG_ADPTYPE_UNKNOWN 0 #define MPI3MR_BSG_ADPTYPE_AVGFAMILY 1 #define MPI3MR_BSG_ADPSTATE_UNKNOWN 0 #define MPI3MR_BSG_ADPSTATE_OPERATIONAL 1 #define MPI3MR_BSG_ADPSTATE_FAULT 2 #define MPI3MR_BSG_ADPSTATE_IN_RESET 3 #define MPI3MR_BSG_ADPSTATE_UNRECOVERABLE 4 #define MPI3MR_BSG_ADPRESET_UNKNOWN 0 #define MPI3MR_BSG_ADPRESET_SOFT 1 #define MPI3MR_BSG_ADPRESET_DIAG_FAULT 2 #define MPI3MR_BSG_LOGDATA_MAX_ENTRIES 400 #define MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ 4 #define MPI3MR_DRVBSG_OPCODE_UNKNOWN 0 #define MPI3MR_DRVBSG_OPCODE_ADPINFO 1 #define MPI3MR_DRVBSG_OPCODE_ADPRESET 2 #define MPI3MR_DRVBSG_OPCODE_ALLTGTDEVINFO 4 #define MPI3MR_DRVBSG_OPCODE_GETCHGCNT 5 #define MPI3MR_DRVBSG_OPCODE_LOGDATAENABLE 6 #define MPI3MR_DRVBSG_OPCODE_PELENABLE 7 #define MPI3MR_DRVBSG_OPCODE_GETLOGDATA 8 #define MPI3MR_DRVBSG_OPCODE_QUERY_HDB 9 #define MPI3MR_DRVBSG_OPCODE_REPOST_HDB 10 #define MPI3MR_DRVBSG_OPCODE_UPLOAD_HDB 11 #define MPI3MR_DRVBSG_OPCODE_REFRESH_HDB_TRIGGERS 12 #define MPI3MR_BSG_BUFTYPE_UNKNOWN 0 #define MPI3MR_BSG_BUFTYPE_RAIDMGMT_CMD 1 #define MPI3MR_BSG_BUFTYPE_RAIDMGMT_RESP 2 #define MPI3MR_BSG_BUFTYPE_DATA_IN 3 #define MPI3MR_BSG_BUFTYPE_DATA_OUT 4 #define MPI3MR_BSG_BUFTYPE_MPI_REPLY 5 #define MPI3MR_BSG_BUFTYPE_ERR_RESPONSE 6 #define MPI3MR_BSG_BUFTYPE_MPI_REQUEST 0xFE #define MPI3MR_BSG_MPI_REPLY_BUFTYPE_UNKNOWN 0 #define MPI3MR_BSG_MPI_REPLY_BUFTYPE_STATUS 1 #define MPI3MR_BSG_MPI_REPLY_BUFTYPE_ADDRESS 2 #define MPI3MR_HDB_BUFTYPE_UNKNOWN 0 #define MPI3MR_HDB_BUFTYPE_TRACE 1 #define MPI3MR_HDB_BUFTYPE_FIRMWARE 2 #define MPI3MR_HDB_BUFTYPE_RESERVED 3 #define MPI3MR_HDB_BUFSTATUS_UNKNOWN 0 #define MPI3MR_HDB_BUFSTATUS_NOT_ALLOCATED 1 #define MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED 2 #define MPI3MR_HDB_BUFSTATUS_POSTED_PAUSED 3 #define MPI3MR_HDB_BUFSTATUS_RELEASED 4 #define MPI3MR_HDB_TRIGGER_TYPE_UNKNOWN 0 #define MPI3MR_HDB_TRIGGER_TYPE_DIAGFAULT 1 #define MPI3MR_HDB_TRIGGER_TYPE_ELEMENT 2 #define MPI3MR_HDB_TRIGGER_TYPE_MASTER 3 /* Supported BSG commands */ enum command { MPI3MR_DRV_CMD = 1, MPI3MR_MPT_CMD = 2, }; /** * struct mpi3_driver_info_layout - Information about driver * * @information_length: Length of this structure in bytes * @driver_signature: Driver Vendor name * @os_name: Operating System Name * @driver_name: Driver name * @driver_version: Driver version * @driver_release_date: Driver release date * @driver_capabilities: Driver capabilities */ struct mpi3_driver_info_layout { __le32 information_length; __u8 driver_signature[12]; __u8 os_name[16]; __u8 os_version[12]; __u8 driver_name[20]; __u8 driver_version[32]; __u8 driver_release_date[20]; __le32 driver_capabilities; }; /** * struct mpi3mr_bsg_in_adpinfo - Adapter information request * data returned by the driver. * * @adp_type: Adapter type * @rsvd1: Reserved * @pci_dev_id: PCI device ID of the adapter * @pci_dev_hw_rev: PCI revision of the adapter * @pci_subsys_dev_id: PCI subsystem device ID of the adapter * @pci_subsys_ven_id: PCI subsystem vendor ID of the adapter * @pci_dev: PCI device * @pci_func: PCI function * @pci_bus: PCI bus * @rsvd2: Reserved * @pci_seg_id: PCI segment ID * @app_intfc_ver: version of the application interface definition * @rsvd3: Reserved * @rsvd4: Reserved * @rsvd5: Reserved * @driver_info: Driver Information (Version/Name) */ struct mpi3mr_bsg_in_adpinfo { __u32 adp_type; __u32 rsvd1; __u32 pci_dev_id; __u32 pci_dev_hw_rev; __u32 pci_subsys_dev_id; __u32 pci_subsys_ven_id; __u32 pci_dev:5; __u32 pci_func:3; __u32 pci_bus:8; __u16 rsvd2; __u32 pci_seg_id; __u32 app_intfc_ver; __u8 adp_state; __u8 rsvd3; __u16 rsvd4; __u32 rsvd5[2]; struct mpi3_driver_info_layout driver_info; }; /** * struct mpi3mr_bsg_adp_reset - Adapter reset request * payload data to the driver. * * @reset_type: Reset type * @rsvd1: Reserved * @rsvd2: Reserved */ struct mpi3mr_bsg_adp_reset { __u8 reset_type; __u8 rsvd1; __u16 rsvd2; }; /** * struct mpi3mr_change_count - Topology change count * returned by the driver. * * @change_count: Topology change count * @rsvd: Reserved */ struct mpi3mr_change_count { __u16 change_count; __u16 rsvd; }; /** * struct mpi3mr_device_map_info - Target device mapping * information * * @handle: Firmware device handle * @perst_id: Persistent ID assigned by the firmware * @target_id: Target ID assigned by the driver * @bus_id: Bus ID assigned by the driver * @rsvd1: Reserved * @rsvd2: Reserved */ struct mpi3mr_device_map_info { __u16 handle; __u16 perst_id; __u32 target_id; __u8 bus_id; __u8 rsvd1; __u16 rsvd2; }; /** * struct mpi3mr_all_tgt_info - Target device mapping * information returned by the driver * * @num_devices: The number of devices in driver's inventory * @rsvd1: Reserved * @rsvd2: Reserved * @dmi: Variable length array of mapping information of targets */ struct mpi3mr_all_tgt_info { __u16 num_devices; __u16 rsvd1; __u32 rsvd2; struct mpi3mr_device_map_info dmi[1]; }; /** * struct mpi3mr_logdata_enable - Number of log data * entries saved by the driver returned as payload data for * enable logdata BSG request by the driver. * * @max_entries: Number of log data entries cached by the driver * @rsvd: Reserved */ struct mpi3mr_logdata_enable { __u16 max_entries; __u16 rsvd; }; /** * struct mpi3mr_bsg_out_pel_enable - PEL enable request payload * data to the driver. * * @pel_locale: PEL locale to the firmware * @pel_class: PEL class to the firmware * @rsvd: Reserved */ struct mpi3mr_bsg_out_pel_enable { __u16 pel_locale; __u8 pel_class; __u8 rsvd; }; /** * struct mpi3mr_logdata_entry - Log data entry cached by the * driver. * * @valid_entry: Is the entry valid * @rsvd1: Reserved * @rsvd2: Reserved * @data: Variable length Log entry data */ struct mpi3mr_logdata_entry { __u8 valid_entry; __u8 rsvd1; __u16 rsvd2; __u8 data[1]; /* Variable length Array */ }; /** * struct mpi3mr_bsg_in_log_data - Log data entries saved by * the driver returned as payload data for Get logdata request * by the driver. * * @entry: Variable length Log data entry array */ struct mpi3mr_bsg_in_log_data { struct mpi3mr_logdata_entry entry[1]; }; /** * struct mpi3mr_hdb_entry - host diag buffer entry. * * @buf_type: Buffer type * @status: Buffer status * @trigger_type: Trigger type * @rsvd1: Reserved * @size: Buffer size * @rsvd2: Reserved * @trigger_data: Trigger specific data * @rsvd3: Reserved * @rsvd4: Reserved */ struct mpi3mr_hdb_entry { __u8 buf_type; __u8 status; __u8 trigger_type; __u8 rsvd1; __u16 size; __u16 rsvd2; __u64 trigger_data; __u32 rsvd3; __u32 rsvd4; }; /** * struct mpi3mr_bsg_in_hdb_status - This structure contains * return data for the BSG request to retrieve the number of host * diagnostic buffers supported by the driver and their current * status and additional status specific data if any in forms of * multiple hdb entries. * * @num_hdb_types: Number of host diag buffer types supported * @rsvd1: Reserved * @rsvd2: Reserved * @rsvd3: Reserved * @entry: Variable length Diag buffer status entry array */ struct mpi3mr_bsg_in_hdb_status { __u8 num_hdb_types; __u8 rsvd1; __u16 rsvd2; __u32 rsvd3; struct mpi3mr_hdb_entry entry[1]; }; /** * struct mpi3mr_bsg_out_repost_hdb - Repost host diagnostic * buffer request payload data to the driver. * * @buf_type: Buffer type * @rsvd1: Reserved * @rsvd2: Reserved */ struct mpi3mr_bsg_out_repost_hdb { __u8 buf_type; __u8 rsvd1; __u16 rsvd2; }; /** * struct mpi3mr_bsg_out_upload_hdb - Upload host diagnostic * buffer request payload data to the driver. * * @buf_type: Buffer type * @rsvd1: Reserved * @rsvd2: Reserved * @start_offset: Start offset of the buffer from where to copy * @length: Length of the buffer to copy */ struct mpi3mr_bsg_out_upload_hdb { __u8 buf_type; __u8 rsvd1; __u16 rsvd2; __u32 start_offset; __u32 length; }; /** * struct mpi3mr_bsg_out_refresh_hdb_triggers - Refresh host * diagnostic buffer triggers request payload data to the driver. * * @page_type: Page type * @rsvd1: Reserved * @rsvd2: Reserved */ struct mpi3mr_bsg_out_refresh_hdb_triggers { __u8 page_type; __u8 rsvd1; __u16 rsvd2; }; /** * struct mpi3mr_bsg_drv_cmd - Generic bsg data * structure for all driver specific requests. * * @mrioc_id: Controller ID * @opcode: Driver specific opcode * @rsvd1: Reserved * @rsvd2: Reserved */ struct mpi3mr_bsg_drv_cmd { __u8 mrioc_id; __u8 opcode; __u16 rsvd1; __u32 rsvd2[4]; }; /** * struct mpi3mr_bsg_in_reply_buf - MPI reply buffer returned * for MPI Passthrough request . * * @mpi_reply_type: Type of MPI reply * @rsvd1: Reserved * @rsvd2: Reserved * @reply_buf: Variable Length buffer based on mpirep type */ struct mpi3mr_bsg_in_reply_buf { __u8 mpi_reply_type; __u8 rsvd1; __u16 rsvd2; __u8 reply_buf[]; }; /** * struct mpi3mr_buf_entry - User buffer descriptor for MPI * Passthrough requests. * * @buf_type: Buffer type * @rsvd1: Reserved * @rsvd2: Reserved * @buf_len: Buffer length */ struct mpi3mr_buf_entry { __u8 buf_type; __u8 rsvd1; __u16 rsvd2; __u32 buf_len; }; /** * struct mpi3mr_bsg_buf_entry_list - list of user buffer * descriptor for MPI Passthrough requests. * * @num_of_entries: Number of buffer descriptors * @rsvd1: Reserved * @rsvd2: Reserved * @rsvd3: Reserved * @buf_entry: Variable length array of buffer descriptors */ struct mpi3mr_buf_entry_list { __u8 num_of_entries; __u8 rsvd1; __u16 rsvd2; __u32 rsvd3; struct mpi3mr_buf_entry buf_entry[1]; }; /** * struct mpi3mr_bsg_mptcmd - Generic bsg data * structure for all MPI Passthrough requests . * * @mrioc_id: Controller ID * @rsvd1: Reserved * @timeout: MPI request timeout * @buf_entry_list: Buffer descriptor list */ struct mpi3mr_bsg_mptcmd { __u8 mrioc_id; __u8 rsvd1; __u16 timeout; __u32 rsvd2; struct mpi3mr_buf_entry_list buf_entry_list; }; /** * struct mpi3mr_bsg_packet - Generic bsg data * structure for all supported requests . * * @cmd_type: represents drvrcmd or mptcmd * @rsvd1: Reserved * @rsvd2: Reserved * @drvrcmd: driver request structure * @mptcmd: mpt request structure */ struct mpi3mr_bsg_packet { __u8 cmd_type; __u8 rsvd1; __u16 rsvd2; __u32 rsvd3; union { struct mpi3mr_bsg_drv_cmd drvrcmd; struct mpi3mr_bsg_mptcmd mptcmd; } cmd; }; /* MPI3: NVMe Encasulation related definitions */ #ifndef MPI3_NVME_ENCAP_CMD_MAX #define MPI3_NVME_ENCAP_CMD_MAX (1) #endif struct mpi3_nvme_encapsulated_request { __le16 host_tag; __u8 ioc_use_only02; __u8 function; __le16 ioc_use_only04; __u8 ioc_use_only06; __u8 msg_flags; __le16 change_count; __le16 dev_handle; __le16 encapsulated_command_length; __le16 flags; __le32 data_length; __le32 reserved14[3]; __le32 command[MPI3_NVME_ENCAP_CMD_MAX]; }; struct mpi3_nvme_encapsulated_error_reply { __le16 host_tag; __u8 ioc_use_only02; __u8 function; __le16 ioc_use_only04; __u8 ioc_use_only06; __u8 msg_flags; __le16 ioc_use_only08; __le16 ioc_status; __le32 ioc_log_info; __le32 nvme_completion_entry[4]; }; #define MPI3MR_NVME_PRP_SIZE 8 /* PRP size */ #define MPI3MR_NVME_CMD_PRP1_OFFSET 24 /* PRP1 offset in NVMe cmd */ #define MPI3MR_NVME_CMD_PRP2_OFFSET 32 /* PRP2 offset in NVMe cmd */ #define MPI3MR_NVME_CMD_SGL_OFFSET 24 /* SGL offset in NVMe cmd */ #define MPI3MR_NVME_DATA_FORMAT_PRP 0 #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 /* MPI3: task management related definitions */ struct mpi3_scsi_task_mgmt_request { __le16 host_tag; __u8 ioc_use_only02; __u8 function; __le16 ioc_use_only04; __u8 ioc_use_only06; __u8 msg_flags; __le16 change_count; __le16 dev_handle; __le16 task_host_tag; __u8 task_type; __u8 reserved0f; __le16 task_request_queue_id; __le16 reserved12; __le32 reserved14; __u8 lun[8]; }; #define MPI3_SCSITASKMGMT_MSGFLAGS_DO_NOT_SEND_TASK_IU (0x08) #define MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK (0x01) #define MPI3_SCSITASKMGMT_TASKTYPE_ABORT_TASK_SET (0x02) #define MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET (0x03) #define MPI3_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET (0x05) #define MPI3_SCSITASKMGMT_TASKTYPE_CLEAR_TASK_SET (0x06) #define MPI3_SCSITASKMGMT_TASKTYPE_QUERY_TASK (0x07) #define MPI3_SCSITASKMGMT_TASKTYPE_CLEAR_ACA (0x08) #define MPI3_SCSITASKMGMT_TASKTYPE_QUERY_TASK_SET (0x09) #define MPI3_SCSITASKMGMT_TASKTYPE_QUERY_ASYNC_EVENT (0x0a) #define MPI3_SCSITASKMGMT_TASKTYPE_I_T_NEXUS_RESET (0x0b) struct mpi3_scsi_task_mgmt_reply { __le16 host_tag; __u8 ioc_use_only02; __u8 function; __le16 ioc_use_only04; __u8 ioc_use_only06; __u8 msg_flags; __le16 ioc_use_only08; __le16 ioc_status; __le32 ioc_log_info; __le32 termination_count; __le32 response_data; __le32 reserved18; }; #define MPI3_SCSITASKMGMT_RSPCODE_TM_COMPLETE (0x00) #define MPI3_SCSITASKMGMT_RSPCODE_INVALID_FRAME (0x02) #define MPI3_SCSITASKMGMT_RSPCODE_TM_FUNCTION_NOT_SUPPORTED (0x04) #define MPI3_SCSITASKMGMT_RSPCODE_TM_FAILED (0x05) #define MPI3_SCSITASKMGMT_RSPCODE_TM_SUCCEEDED (0x08) #define MPI3_SCSITASKMGMT_RSPCODE_TM_INVALID_LUN (0x09) #define MPI3_SCSITASKMGMT_RSPCODE_TM_OVERLAPPED_TAG (0x0a) #define MPI3_SCSITASKMGMT_RSPCODE_IO_QUEUED_ON_IOC (0x80) #define MPI3_SCSITASKMGMT_RSPCODE_TM_NVME_DENIED (0x81) /* MPI3: PEL related definitions */ #define MPI3_PEL_LOCALE_FLAGS_NON_BLOCKING_BOOT_EVENT (0x0200) #define MPI3_PEL_LOCALE_FLAGS_BLOCKING_BOOT_EVENT (0x0100) #define MPI3_PEL_LOCALE_FLAGS_PCIE (0x0080) #define MPI3_PEL_LOCALE_FLAGS_CONFIGURATION (0x0040) #define MPI3_PEL_LOCALE_FLAGS_CONTROLER (0x0020) #define MPI3_PEL_LOCALE_FLAGS_SAS (0x0010) #define MPI3_PEL_LOCALE_FLAGS_EPACK (0x0008) #define MPI3_PEL_LOCALE_FLAGS_ENCLOSURE (0x0004) #define MPI3_PEL_LOCALE_FLAGS_PD (0x0002) #define MPI3_PEL_LOCALE_FLAGS_VD (0x0001) #define MPI3_PEL_CLASS_DEBUG (0x00) #define MPI3_PEL_CLASS_PROGRESS (0x01) #define MPI3_PEL_CLASS_INFORMATIONAL (0x02) #define MPI3_PEL_CLASS_WARNING (0x03) #define MPI3_PEL_CLASS_CRITICAL (0x04) #define MPI3_PEL_CLASS_FATAL (0x05) #define MPI3_PEL_CLASS_FAULT (0x06) /* MPI3: Function definitions */ #define MPI3_BSG_FUNCTION_MGMT_PASSTHROUGH (0x0a) #define MPI3_BSG_FUNCTION_SCSI_IO (0x20) #define MPI3_BSG_FUNCTION_SCSI_TASK_MGMT (0x21) #define MPI3_BSG_FUNCTION_SMP_PASSTHROUGH (0x22) #define MPI3_BSG_FUNCTION_NVME_ENCAPSULATED (0x24) #endif scsi/scsi_netlink_fc.h000064400000003711152640040160011013 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * FC Transport Netlink Interface * * Copyright (C) 2006 James Smart, Emulex Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #ifndef SCSI_NETLINK_FC_H #define SCSI_NETLINK_FC_H #include /* * This file intended to be included by both kernel and user space */ /* * FC Transport Message Types */ /* kernel -> user */ #define FC_NL_ASYNC_EVENT 0x0100 /* user -> kernel */ /* none */ /* * Message Structures : */ /* macro to round up message lengths to 8byte boundary */ #define FC_NL_MSGALIGN(len) (((len) + 7) & ~7) /* * FC Transport Broadcast Event Message : * FC_NL_ASYNC_EVENT * * Note: if Vendor Unique message, &event_data will be start of * vendor unique payload, and the length of the payload is * per event_datalen * * Note: When specifying vendor_id, be sure to read the Vendor Type and ID * formatting requirements specified in scsi_netlink.h */ struct fc_nl_event { struct scsi_nl_hdr snlh; /* must be 1st element ! */ uint64_t seconds; uint64_t vendor_id; uint16_t host_no; uint16_t event_datalen; uint32_t event_num; uint32_t event_code; uint32_t event_data; } __attribute__((aligned(sizeof(uint64_t)))); #endif /* SCSI_NETLINK_FC_H */ scsi/cxlflash_ioctl.h000064400000023670152640040160010662 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * CXL Flash Device Driver * * Written by: Manoj N. Kumar , IBM Corporation * Matthew R. Ochs , IBM Corporation * * Copyright (C) 2015 IBM Corporation * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #ifndef _CXLFLASH_IOCTL_H #define _CXLFLASH_IOCTL_H #include /* * Structure and definitions for all CXL Flash ioctls */ #define CXLFLASH_WWID_LEN 16 /* * Structure and flag definitions CXL Flash superpipe ioctls */ #define DK_CXLFLASH_VERSION_0 0 struct dk_cxlflash_hdr { __u16 version; /* Version data */ __u16 rsvd[3]; /* Reserved for future use */ __u64 flags; /* Input flags */ __u64 return_flags; /* Returned flags */ }; /* * Return flag definitions available to all superpipe ioctls * * Similar to the input flags, these are grown from the bottom-up with the * intention that ioctl-specific return flag definitions would grow from the * top-down, allowing the two sets to co-exist. While not required/enforced * at this time, this provides future flexibility. */ #define DK_CXLFLASH_ALL_PORTS_ACTIVE 0x0000000000000001ULL #define DK_CXLFLASH_APP_CLOSE_ADAP_FD 0x0000000000000002ULL #define DK_CXLFLASH_CONTEXT_SQ_CMD_MODE 0x0000000000000004ULL /* * General Notes: * ------------- * The 'context_id' field of all ioctl structures contains the context * identifier for a context in the lower 32-bits (upper 32-bits are not * to be used when identifying a context to the AFU). That said, the value * in its entirety (all 64-bits) is to be treated as an opaque cookie and * should be presented as such when issuing ioctls. */ /* * DK_CXLFLASH_ATTACH Notes: * ------------------------ * Read/write access permissions are specified via the O_RDONLY, O_WRONLY, * and O_RDWR flags defined in the fcntl.h header file. * * A valid adapter file descriptor (fd >= 0) is only returned on the initial * attach (successful) of a context. When a context is shared(reused), the user * is expected to already 'know' the adapter file descriptor associated with the * context. */ #define DK_CXLFLASH_ATTACH_REUSE_CONTEXT 0x8000000000000000ULL struct dk_cxlflash_attach { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 num_interrupts; /* Requested number of interrupts */ __u64 context_id; /* Returned context */ __u64 mmio_size; /* Returned size of MMIO area */ __u64 block_size; /* Returned block size, in bytes */ __u64 adap_fd; /* Returned adapter file descriptor */ __u64 last_lba; /* Returned last LBA on the device */ __u64 max_xfer; /* Returned max transfer size, blocks */ __u64 reserved[8]; /* Reserved for future use */ }; struct dk_cxlflash_detach { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context to detach */ __u64 reserved[8]; /* Reserved for future use */ }; struct dk_cxlflash_udirect { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context to own physical resources */ __u64 rsrc_handle; /* Returned resource handle */ __u64 last_lba; /* Returned last LBA on the device */ __u64 reserved[8]; /* Reserved for future use */ }; #define DK_CXLFLASH_UVIRTUAL_NEED_WRITE_SAME 0x8000000000000000ULL struct dk_cxlflash_uvirtual { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context to own virtual resources */ __u64 lun_size; /* Requested size, in 4K blocks */ __u64 rsrc_handle; /* Returned resource handle */ __u64 last_lba; /* Returned last LBA of LUN */ __u64 reserved[8]; /* Reserved for future use */ }; struct dk_cxlflash_release { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context owning resources */ __u64 rsrc_handle; /* Resource handle to release */ __u64 reserved[8]; /* Reserved for future use */ }; struct dk_cxlflash_resize { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context owning resources */ __u64 rsrc_handle; /* Resource handle of LUN to resize */ __u64 req_size; /* New requested size, in 4K blocks */ __u64 last_lba; /* Returned last LBA of LUN */ __u64 reserved[8]; /* Reserved for future use */ }; struct dk_cxlflash_clone { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id_src; /* Context to clone from */ __u64 context_id_dst; /* Context to clone to */ __u64 adap_fd_src; /* Source context adapter fd */ __u64 reserved[8]; /* Reserved for future use */ }; #define DK_CXLFLASH_VERIFY_SENSE_LEN 18 #define DK_CXLFLASH_VERIFY_HINT_SENSE 0x8000000000000000ULL struct dk_cxlflash_verify { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 context_id; /* Context owning resources to verify */ __u64 rsrc_handle; /* Resource handle of LUN */ __u64 hint; /* Reasons for verify */ __u64 last_lba; /* Returned last LBA of device */ __u8 sense_data[DK_CXLFLASH_VERIFY_SENSE_LEN]; /* SCSI sense data */ __u8 pad[6]; /* Pad to next 8-byte boundary */ __u64 reserved[8]; /* Reserved for future use */ }; #define DK_CXLFLASH_RECOVER_AFU_CONTEXT_RESET 0x8000000000000000ULL struct dk_cxlflash_recover_afu { struct dk_cxlflash_hdr hdr; /* Common fields */ __u64 reason; /* Reason for recovery request */ __u64 context_id; /* Context to recover / updated ID */ __u64 mmio_size; /* Returned size of MMIO area */ __u64 adap_fd; /* Returned adapter file descriptor */ __u64 reserved[8]; /* Reserved for future use */ }; #define DK_CXLFLASH_MANAGE_LUN_WWID_LEN CXLFLASH_WWID_LEN #define DK_CXLFLASH_MANAGE_LUN_ENABLE_SUPERPIPE 0x8000000000000000ULL #define DK_CXLFLASH_MANAGE_LUN_DISABLE_SUPERPIPE 0x4000000000000000ULL #define DK_CXLFLASH_MANAGE_LUN_ALL_PORTS_ACCESSIBLE 0x2000000000000000ULL struct dk_cxlflash_manage_lun { struct dk_cxlflash_hdr hdr; /* Common fields */ __u8 wwid[DK_CXLFLASH_MANAGE_LUN_WWID_LEN]; /* Page83 WWID, NAA-6 */ __u64 reserved[8]; /* Rsvd, future use */ }; union cxlflash_ioctls { struct dk_cxlflash_attach attach; struct dk_cxlflash_detach detach; struct dk_cxlflash_udirect udirect; struct dk_cxlflash_uvirtual uvirtual; struct dk_cxlflash_release release; struct dk_cxlflash_resize resize; struct dk_cxlflash_clone clone; struct dk_cxlflash_verify verify; struct dk_cxlflash_recover_afu recover_afu; struct dk_cxlflash_manage_lun manage_lun; }; #define MAX_CXLFLASH_IOCTL_SZ (sizeof(union cxlflash_ioctls)) #define CXL_MAGIC 0xCA #define CXL_IOWR(_n, _s) _IOWR(CXL_MAGIC, _n, struct _s) /* * CXL Flash superpipe ioctls start at base of the reserved CXL_MAGIC * region (0x80) and grow upwards. */ #define DK_CXLFLASH_ATTACH CXL_IOWR(0x80, dk_cxlflash_attach) #define DK_CXLFLASH_USER_DIRECT CXL_IOWR(0x81, dk_cxlflash_udirect) #define DK_CXLFLASH_RELEASE CXL_IOWR(0x82, dk_cxlflash_release) #define DK_CXLFLASH_DETACH CXL_IOWR(0x83, dk_cxlflash_detach) #define DK_CXLFLASH_VERIFY CXL_IOWR(0x84, dk_cxlflash_verify) #define DK_CXLFLASH_RECOVER_AFU CXL_IOWR(0x85, dk_cxlflash_recover_afu) #define DK_CXLFLASH_MANAGE_LUN CXL_IOWR(0x86, dk_cxlflash_manage_lun) #define DK_CXLFLASH_USER_VIRTUAL CXL_IOWR(0x87, dk_cxlflash_uvirtual) #define DK_CXLFLASH_VLUN_RESIZE CXL_IOWR(0x88, dk_cxlflash_resize) #define DK_CXLFLASH_VLUN_CLONE CXL_IOWR(0x89, dk_cxlflash_clone) /* * Structure and flag definitions CXL Flash host ioctls */ #define HT_CXLFLASH_VERSION_0 0 struct ht_cxlflash_hdr { __u16 version; /* Version data */ __u16 subcmd; /* Sub-command */ __u16 rsvd[2]; /* Reserved for future use */ __u64 flags; /* Input flags */ __u64 return_flags; /* Returned flags */ }; /* * Input flag definitions available to all host ioctls * * These are grown from the bottom-up with the intention that ioctl-specific * input flag definitions would grow from the top-down, allowing the two sets * to co-exist. While not required/enforced at this time, this provides future * flexibility. */ #define HT_CXLFLASH_HOST_READ 0x0000000000000000ULL #define HT_CXLFLASH_HOST_WRITE 0x0000000000000001ULL #define HT_CXLFLASH_LUN_PROVISION_SUBCMD_CREATE_LUN 0x0001 #define HT_CXLFLASH_LUN_PROVISION_SUBCMD_DELETE_LUN 0x0002 #define HT_CXLFLASH_LUN_PROVISION_SUBCMD_QUERY_PORT 0x0003 struct ht_cxlflash_lun_provision { struct ht_cxlflash_hdr hdr; /* Common fields */ __u16 port; /* Target port for provision request */ __u16 reserved16[3]; /* Reserved for future use */ __u64 size; /* Size of LUN (4K blocks) */ __u64 lun_id; /* SCSI LUN ID */ __u8 wwid[CXLFLASH_WWID_LEN];/* Page83 WWID, NAA-6 */ __u64 max_num_luns; /* Maximum number of LUNs provisioned */ __u64 cur_num_luns; /* Current number of LUNs provisioned */ __u64 max_cap_port; /* Total capacity for port (4K blocks) */ __u64 cur_cap_port; /* Current capacity for port (4K blocks) */ __u64 reserved[8]; /* Reserved for future use */ }; #define HT_CXLFLASH_AFU_DEBUG_MAX_DATA_LEN 262144 /* 256K */ #define HT_CXLFLASH_AFU_DEBUG_SUBCMD_LEN 12 struct ht_cxlflash_afu_debug { struct ht_cxlflash_hdr hdr; /* Common fields */ __u8 reserved8[4]; /* Reserved for future use */ __u8 afu_subcmd[HT_CXLFLASH_AFU_DEBUG_SUBCMD_LEN]; /* AFU subcommand, * (pass through) */ __u64 data_ea; /* Data buffer effective address */ __u32 data_len; /* Data buffer length */ __u32 reserved32; /* Reserved for future use */ __u64 reserved[8]; /* Reserved for future use */ }; union cxlflash_ht_ioctls { struct ht_cxlflash_lun_provision lun_provision; struct ht_cxlflash_afu_debug afu_debug; }; #define MAX_HT_CXLFLASH_IOCTL_SZ (sizeof(union cxlflash_ht_ioctls)) /* * CXL Flash host ioctls start at the top of the reserved CXL_MAGIC * region (0xBF) and grow downwards. */ #define HT_CXLFLASH_LUN_PROVISION CXL_IOWR(0xBF, ht_cxlflash_lun_provision) #define HT_CXLFLASH_AFU_DEBUG CXL_IOWR(0xBE, ht_cxlflash_afu_debug) #endif /* ifndef _CXLFLASH_IOCTL_H */ scsi/sg.h000064400000026615152640040160006277 0ustar00/* Copyright (C) 1997-2018 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 . */ /* History: Started: Aug 9 by Lawrence Foard (entropy@world.std.com), to allow user process control of SCSI devices. Development Sponsored by Killy Corp. NY NY */ #ifndef _SCSI_SG_H #define _SCSI_SG_H 1 #include #define __need_size_t #include /* New interface introduced in the 3.x SG drivers follows */ /* Same structure as used by readv() Linux system call. It defines one scatter-gather element. */ typedef struct sg_iovec { void * iov_base; /* Starting address */ size_t iov_len; /* Length in bytes */ } sg_iovec_t; typedef struct sg_io_hdr { int interface_id; /* [i] 'S' for SCSI generic (required) */ int dxfer_direction; /* [i] data transfer direction */ unsigned char cmd_len; /* [i] SCSI command length ( <= 16 bytes) */ unsigned char mx_sb_len; /* [i] max length to write to sbp */ unsigned short int iovec_count; /* [i] 0 implies no scatter gather */ unsigned int dxfer_len; /* [i] byte count of data transfer */ void * dxferp; /* [i], [*io] points to data transfer memory or scatter gather list */ unsigned char * cmdp; /* [i], [*i] points to command to perform */ unsigned char * sbp; /* [i], [*o] points to sense_buffer memory */ unsigned int timeout; /* [i] MAX_UINT->no timeout (unit: millisec) */ unsigned int flags; /* [i] 0 -> default, see SG_FLAG... */ int pack_id; /* [i->o] unused internally (normally) */ void * usr_ptr; /* [i->o] unused internally */ unsigned char status; /* [o] scsi status */ unsigned char masked_status;/* [o] shifted, masked scsi status */ unsigned char msg_status; /* [o] messaging level data (optional) */ unsigned char sb_len_wr; /* [o] byte count actually written to sbp */ unsigned short int host_status; /* [o] errors from host adapter */ unsigned short int driver_status;/* [o] errors from software driver */ int resid; /* [o] dxfer_len - actual_transferred */ unsigned int duration; /* [o] time taken by cmd (unit: millisec) */ unsigned int info; /* [o] auxiliary information */ } sg_io_hdr_t; /* Use negative values to flag difference from original sg_header structure. */ #define SG_DXFER_NONE -1 /* e.g. a SCSI Test Unit Ready command */ #define SG_DXFER_TO_DEV -2 /* e.g. a SCSI WRITE command */ #define SG_DXFER_FROM_DEV -3 /* e.g. a SCSI READ command */ #define SG_DXFER_TO_FROM_DEV -4 /* treated like SG_DXFER_FROM_DEV with the additional property than during indirect IO the user buffer is copied into the kernel buffers before the transfer */ /* following flag values can be "or"-ed together */ #define SG_FLAG_DIRECT_IO 1 /* default is indirect IO */ #define SG_FLAG_LUN_INHIBIT 2 /* default is to put device's lun into */ /* the 2nd byte of SCSI command */ #define SG_FLAG_NO_DXFER 0x10000 /* no transfer of kernel buffers to/from */ /* user space (debug indirect IO) */ /* The following 'info' values are "or"-ed together. */ #define SG_INFO_OK_MASK 0x1 #define SG_INFO_OK 0x0 /* no sense, host nor driver "noise" */ #define SG_INFO_CHECK 0x1 /* something abnormal happened */ #define SG_INFO_DIRECT_IO_MASK 0x6 #define SG_INFO_INDIRECT_IO 0x0 /* data xfer via kernel buffers (or no xfer) */ #define SG_INFO_DIRECT_IO 0x2 /* direct IO requested and performed */ #define SG_INFO_MIXED_IO 0x4 /* part direct, part indirect IO */ /* Request information about a specific SG device, used by SG_GET_SCSI_ID ioctl (). */ struct sg_scsi_id { /* Host number as in "scsi" where 'n' is one of 0, 1, 2 etc. */ int host_no; int channel; /* SCSI id of target device. */ int scsi_id; int lun; /* TYPE_... defined in . */ int scsi_type; /* Host (adapter) maximum commands per lun. */ short int h_cmd_per_lun; /* Device (or adapter) maximum queue length. */ short int d_queue_depth; /* Unused, set to 0 for now. */ int unused[2]; }; /* Used by SG_GET_REQUEST_TABLE ioctl(). */ typedef struct sg_req_info { char req_state; /* 0 -> not used, 1 -> written, 2 -> ready to read */ char orphan; /* 0 -> normal request, 1 -> from interruped SG_IO */ char sg_io_owned; /* 0 -> complete with read(), 1 -> owned by SG_IO */ char problem; /* 0 -> no problem detected, 1 -> error to report */ int pack_id; /* pack_id associated with request */ void * usr_ptr; /* user provided pointer (in new interface) */ unsigned int duration; /* millisecs elapsed since written (req_state==1) or request duration (req_state==2) */ int unused; } sg_req_info_t; /* IOCTLs: Those ioctls that are relevant to the SG 3.x drivers follow. [Those that only apply to the SG 2.x drivers are at the end of the file.] (_GET_s yield result via 'int *' 3rd argument unless otherwise indicated) */ #define SG_EMULATED_HOST 0x2203 /* true for emulated host adapter (ATAPI) */ /* Used to configure SCSI command transformation layer for ATAPI devices */ /* Only supported by the ide-scsi driver */ #define SG_SET_TRANSFORM 0x2204 /* N.B. 3rd arg is not pointer but value: */ /* 3rd arg = 0 to disable transform, 1 to enable it */ #define SG_GET_TRANSFORM 0x2205 #define SG_SET_RESERVED_SIZE 0x2275 /* request a new reserved buffer size */ #define SG_GET_RESERVED_SIZE 0x2272 /* actual size of reserved buffer */ /* The following ioctl has a 'sg_scsi_id_t *' object as its 3rd argument. */ #define SG_GET_SCSI_ID 0x2276 /* Yields fd's bus, chan, dev, lun + type */ /* SCSI id information can also be obtained from SCSI_IOCTL_GET_IDLUN */ /* Override host setting and always DMA using low memory ( <16MB on i386) */ #define SG_SET_FORCE_LOW_DMA 0x2279 /* 0-> use adapter setting, 1-> force */ #define SG_GET_LOW_DMA 0x227a /* 0-> use all ram for dma; 1-> low dma ram */ /* When SG_SET_FORCE_PACK_ID set to 1, pack_id is input to read() which tries to fetch a packet with a matching pack_id, waits, or returns EAGAIN. If pack_id is -1 then read oldest waiting. When ...FORCE_PACK_ID set to 0 then pack_id ignored by read() and oldest readable fetched. */ #define SG_SET_FORCE_PACK_ID 0x227b #define SG_GET_PACK_ID 0x227c /* Yields oldest readable pack_id (or -1) */ #define SG_GET_NUM_WAITING 0x227d /* Number of commands awaiting read() */ /* Yields max scatter gather tablesize allowed by current host adapter */ #define SG_GET_SG_TABLESIZE 0x227F /* 0 implies can't do scatter gather */ #define SG_GET_VERSION_NUM 0x2282 /* Example: version 2.1.34 yields 20134 */ /* Returns -EBUSY if occupied. 3rd argument pointer to int (see next) */ #define SG_SCSI_RESET 0x2284 /* Associated values that can be given to SG_SCSI_RESET follow */ #define SG_SCSI_RESET_NOTHING 0 #define SG_SCSI_RESET_DEVICE 1 #define SG_SCSI_RESET_BUS 2 #define SG_SCSI_RESET_HOST 3 /* synchronous SCSI command ioctl, (only in version 3 interface) */ #define SG_IO 0x2285 /* similar effect as write() followed by read() */ #define SG_GET_REQUEST_TABLE 0x2286 /* yields table of active requests */ /* How to treat EINTR during SG_IO ioctl(), only in SG 3.x series */ #define SG_SET_KEEP_ORPHAN 0x2287 /* 1 -> hold for read(), 0 -> drop (def) */ #define SG_GET_KEEP_ORPHAN 0x2288 #define SG_SCATTER_SZ (8 * 4096) /* PAGE_SIZE not available to user */ /* Largest size (in bytes) a single scatter-gather list element can have. The value must be a power of 2 and <= (PAGE_SIZE * 32) [131072 bytes on i386]. The minimum value is PAGE_SIZE. If scatter-gather not supported by adapter then this value is the largest data block that can be read/written by a single scsi command. The user can find the value of PAGE_SIZE by calling getpagesize() defined in unistd.h . */ #define SG_DEFAULT_RETRIES 1 /* Defaults, commented if they differ from original sg driver */ #define SG_DEF_FORCE_LOW_DMA 0 /* was 1 -> memory below 16MB on i386 */ #define SG_DEF_FORCE_PACK_ID 0 #define SG_DEF_KEEP_ORPHAN 0 #define SG_DEF_RESERVED_SIZE SG_SCATTER_SZ /* load time option */ /* maximum outstanding requests, write() yields EDOM if exceeded */ #define SG_MAX_QUEUE 16 #define SG_BIG_BUFF SG_DEF_RESERVED_SIZE /* for backward compatibility */ /* Alternate style type names, "..._t" variants preferred */ typedef struct sg_io_hdr Sg_io_hdr; typedef struct sg_io_vec Sg_io_vec; typedef struct sg_scsi_id Sg_scsi_id; typedef struct sg_req_info Sg_req_info; /* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */ /* The older SG interface based on the 'sg_header' structure follows. */ /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ #define SG_MAX_SENSE 16 /* this only applies to the sg_header interface */ struct sg_header { /* Length of incoming packet (including header). */ int pack_len; /* Maximal length of expected reply. */ int reply_len; /* Id number of packet. */ int pack_id; /* 0==ok, otherwise error number. */ int result; /* Force 12 byte command length for group 6 & 7 commands. */ unsigned int twelve_byte:1; /* SCSI status from target. */ unsigned int target_status:5; /* Host status (see "DID" codes). */ unsigned int host_status:8; /* Driver status+suggestion. */ unsigned int driver_status:8; /* Unused. */ unsigned int other_flags:10; /* Output in 3 cases: when target_status is CHECK_CONDITION or when target_status is COMMAND_TERMINATED or when (driver_status & DRIVER_SENSE) is true. */ unsigned char sense_buffer[SG_MAX_SENSE]; }; /* IOCTLs: The following are not required (or ignored) when the sg_io_hdr_t interface is used. They are kept for backward compatibility with the original and version 2 drivers. */ #define SG_SET_TIMEOUT 0x2201 /* Set timeout; *(int *)arg==timeout. */ #define SG_GET_TIMEOUT 0x2202 /* Get timeout; return timeout. */ /* Get/set command queuing state per fd (default is SG_DEF_COMMAND_Q). */ #define SG_GET_COMMAND_Q 0x2270 /* Yields 0 (queuing off) or 1 (on). */ #define SG_SET_COMMAND_Q 0x2271 /* Change queuing state with 0 or 1. */ /* Turn on error sense trace (1..8), dump this device to log/console (9) or dump all sg device states ( >9 ) to log/console. */ #define SG_SET_DEBUG 0x227e /* 0 -> turn off debug */ #define SG_NEXT_CMD_LEN 0x2283 /* Override SCSI command length with given number on the next write() on this file descriptor. */ /* Defaults, commented if they differ from original sg driver */ #define SG_DEFAULT_TIMEOUT (60*HZ) /* HZ == 'jiffies in 1 second' */ #define SG_DEF_COMMAND_Q 0 /* command queuing is always on when the new interface is used */ #define SG_DEF_UNDERRUN_FLAG 0 #endif /* scsi/sg.h */ scsi/scsi_ioctl.h000064400000002443152640040160010012 0ustar00/* Copyright (C) 1999-2018 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 . */ #ifndef _SCSI_IOCTL_H #define _SCSI_IOCTL_H /* IOCTLs for SCSI. */ #define SCSI_IOCTL_SEND_COMMAND 1 /* Send a command to the SCSI host. */ #define SCSI_IOCTL_TEST_UNIT_READY 2 /* Test if unit is ready. */ #define SCSI_IOCTL_BENCHMARK_COMMAND 3 #define SCSI_IOCTL_SYNC 4 /* Request synchronous parameters. */ #define SCSI_IOCTL_START_UNIT 5 #define SCSI_IOCTL_STOP_UNIT 6 #define SCSI_IOCTL_DOORLOCK 0x5380 /* Lock the eject mechanism. */ #define SCSI_IOCTL_DOORUNLOCK 0x5381 /* Unlock the mechanism. */ #endif scsi/scsi_netlink.h000064400000007122152640040160010343 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * SCSI Transport Netlink Interface * Used for the posting of outbound SCSI transport events * * Copyright (C) 2006 James Smart, Emulex Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #ifndef SCSI_NETLINK_H #define SCSI_NETLINK_H #include #include /* * This file intended to be included by both kernel and user space */ /* Single Netlink Message type to send all SCSI Transport messages */ #define SCSI_TRANSPORT_MSG NLMSG_MIN_TYPE + 1 /* SCSI Transport Broadcast Groups */ /* leaving groups 0 and 1 unassigned */ #define SCSI_NL_GRP_FC_EVENTS (1<<2) /* Group 2 */ #define SCSI_NL_GRP_CNT 3 /* SCSI_TRANSPORT_MSG event message header */ struct scsi_nl_hdr { uint8_t version; uint8_t transport; uint16_t magic; uint16_t msgtype; uint16_t msglen; } __attribute__((aligned(sizeof(uint64_t)))); /* scsi_nl_hdr->version value */ #define SCSI_NL_VERSION 1 /* scsi_nl_hdr->magic value */ #define SCSI_NL_MAGIC 0xA1B2 /* scsi_nl_hdr->transport value */ #define SCSI_NL_TRANSPORT 0 #define SCSI_NL_TRANSPORT_FC 1 #define SCSI_NL_MAX_TRANSPORTS 2 /* Transport-based scsi_nl_hdr->msgtype values are defined in each transport */ /* * GENERIC SCSI scsi_nl_hdr->msgtype Values */ /* kernel -> user */ #define SCSI_NL_SHOST_VENDOR 0x0001 /* user -> kernel */ /* SCSI_NL_SHOST_VENDOR msgtype is kernel->user and user->kernel */ /* * Message Structures : */ /* macro to round up message lengths to 8byte boundary */ #define SCSI_NL_MSGALIGN(len) (((len) + 7) & ~7) /* * SCSI HOST Vendor Unique messages : * SCSI_NL_SHOST_VENDOR * * Note: The Vendor Unique message payload will begin directly after * this structure, with the length of the payload per vmsg_datalen. * * Note: When specifying vendor_id, be sure to read the Vendor Type and ID * formatting requirements specified below */ struct scsi_nl_host_vendor_msg { struct scsi_nl_hdr snlh; /* must be 1st element ! */ uint64_t vendor_id; uint16_t host_no; uint16_t vmsg_datalen; } __attribute__((aligned(sizeof(uint64_t)))); /* * Vendor ID: * If transports post vendor-unique events, they must pass a well-known * 32-bit vendor identifier. This identifier consists of 8 bits indicating * the "type" of identifier contained, and 24 bits of id data. * * Identifiers for each type: * PCI : ID data is the 16 bit PCI Registered Vendor ID */ #define SCSI_NL_VID_TYPE_SHIFT 56 #define SCSI_NL_VID_TYPE_MASK ((__u64)0xFF << SCSI_NL_VID_TYPE_SHIFT) #define SCSI_NL_VID_TYPE_PCI ((__u64)0x01 << SCSI_NL_VID_TYPE_SHIFT) #define SCSI_NL_VID_ID_MASK (~ SCSI_NL_VID_TYPE_MASK) #define INIT_SCSI_NL_HDR(hdr, t, mtype, mlen) \ { \ (hdr)->version = SCSI_NL_VERSION; \ (hdr)->transport = t; \ (hdr)->magic = SCSI_NL_MAGIC; \ (hdr)->msgtype = mtype; \ (hdr)->msglen = mlen; \ } #endif /* SCSI_NETLINK_H */ scsi/scsi_bsg_fc.h000064400000021161152640040160010121 0ustar00/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ /* * FC Transport BSG Interface * * Copyright (C) 2008 James Smart, Emulex Corporation * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ #ifndef SCSI_BSG_FC_H #define SCSI_BSG_FC_H /* * This file intended to be included by both kernel and user space */ /* * FC Transport SGIO v4 BSG Message Support */ /* Default BSG request timeout (in seconds) */ #define FC_DEFAULT_BSG_TIMEOUT (10 * HZ) /* * Request Message Codes supported by the FC Transport */ /* define the class masks for the message codes */ #define FC_BSG_CLS_MASK 0xF0000000 /* find object class */ #define FC_BSG_HST_MASK 0x80000000 /* fc host class */ #define FC_BSG_RPT_MASK 0x40000000 /* fc rport class */ /* fc_host Message Codes */ #define FC_BSG_HST_ADD_RPORT (FC_BSG_HST_MASK | 0x00000001) #define FC_BSG_HST_DEL_RPORT (FC_BSG_HST_MASK | 0x00000002) #define FC_BSG_HST_ELS_NOLOGIN (FC_BSG_HST_MASK | 0x00000003) #define FC_BSG_HST_CT (FC_BSG_HST_MASK | 0x00000004) #define FC_BSG_HST_VENDOR (FC_BSG_HST_MASK | 0x000000FF) /* fc_rport Message Codes */ #define FC_BSG_RPT_ELS (FC_BSG_RPT_MASK | 0x00000001) #define FC_BSG_RPT_CT (FC_BSG_RPT_MASK | 0x00000002) /* * FC Address Identifiers in Message Structures : * * Whenever a command payload contains a FC Address Identifier * (aka port_id), the value is effectively in big-endian * order, thus the array elements are decoded as follows: * element [0] is bits 23:16 of the FC Address Identifier * element [1] is bits 15:8 of the FC Address Identifier * element [2] is bits 7:0 of the FC Address Identifier */ /* * FC Host Messages */ /* FC_BSG_HST_ADDR_PORT : */ /* Request: * This message requests the FC host to login to the remote port * at the specified N_Port_Id. The remote port is to be enumerated * with the transport upon completion of the login. */ struct fc_bsg_host_add_rport { uint8_t reserved; /* FC Address Identier of the remote port to login to */ uint8_t port_id[3]; }; /* Response: * There is no additional response data - fc_bsg_reply->result is sufficient */ /* FC_BSG_HST_DEL_RPORT : */ /* Request: * This message requests the FC host to remove an enumerated * remote port and to terminate the login to it. * * Note: The driver is free to reject this request if it desires to * remain logged in with the remote port. */ struct fc_bsg_host_del_rport { uint8_t reserved; /* FC Address Identier of the remote port to logout of */ uint8_t port_id[3]; }; /* Response: * There is no additional response data - fc_bsg_reply->result is sufficient */ /* FC_BSG_HST_ELS_NOLOGIN : */ /* Request: * This message requests the FC_Host to send an ELS to a specific * N_Port_ID. The host does not need to log into the remote port, * nor does it need to enumerate the rport for further traffic * (although, the FC host is free to do so if it desires). */ struct fc_bsg_host_els { /* * ELS Command Code being sent (must be the same as byte 0 * of the payload) */ uint8_t command_code; /* FC Address Identier of the remote port to send the ELS to */ uint8_t port_id[3]; }; /* Response: */ /* fc_bsg_ctels_reply->status values */ #define FC_CTELS_STATUS_OK 0x00000000 #define FC_CTELS_STATUS_REJECT 0x00000001 #define FC_CTELS_STATUS_P_RJT 0x00000002 #define FC_CTELS_STATUS_F_RJT 0x00000003 #define FC_CTELS_STATUS_P_BSY 0x00000004 #define FC_CTELS_STATUS_F_BSY 0x00000006 struct fc_bsg_ctels_reply { /* * Note: An ELS LS_RJT may be reported in 2 ways: * a) A status of FC_CTELS_STATUS_OK is returned. The caller * is to look into the ELS receive payload to determine * LS_ACC or LS_RJT (by contents of word 0). The reject * data will be in word 1. * b) A status of FC_CTELS_STATUS_REJECT is returned, The * rjt_data field will contain valid data. * * Note: ELS LS_ACC is determined by an FC_CTELS_STATUS_OK, and * the receive payload word 0 indicates LS_ACC * (e.g. value is 0x02xxxxxx). * * Note: Similarly, a CT Reject may be reported in 2 ways: * a) A status of FC_CTELS_STATUS_OK is returned. The caller * is to look into the CT receive payload to determine * Accept or Reject (by contents of word 2). The reject * data will be in word 3. * b) A status of FC_CTELS_STATUS_REJECT is returned, The * rjt_data field will contain valid data. * * Note: x_RJT/BSY status will indicae that the rjt_data field * is valid and contains the reason/explanation values. */ uint32_t status; /* See FC_CTELS_STATUS_xxx */ /* valid if status is not FC_CTELS_STATUS_OK */ struct { uint8_t action; /* fragment_id for CT REJECT */ uint8_t reason_code; uint8_t reason_explanation; uint8_t vendor_unique; } rjt_data; }; /* FC_BSG_HST_CT : */ /* Request: * This message requests that a CT Request be performed with the * indicated N_Port_ID. The driver is responsible for logging in with * the fabric and/or N_Port_ID, etc as per FC rules. This request does * not mandate that the driver must enumerate the destination in the * transport. The driver is allowed to decide whether to enumerate it, * and whether to tear it down after the request. */ struct fc_bsg_host_ct { uint8_t reserved; /* FC Address Identier of the remote port to send the ELS to */ uint8_t port_id[3]; /* * We need words 0-2 of the generic preamble for the LLD's */ uint32_t preamble_word0; /* revision & IN_ID */ uint32_t preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */ uint32_t preamble_word2; /* Cmd Code, Max Size */ }; /* Response: * * The reply structure is an fc_bsg_ctels_reply structure */ /* FC_BSG_HST_VENDOR : */ /* Request: * Note: When specifying vendor_id, be sure to read the Vendor Type and ID * formatting requirements specified in scsi_netlink.h */ struct fc_bsg_host_vendor { /* * Identifies the vendor that the message is formatted for. This * should be the recipient of the message. */ uint64_t vendor_id; /* start of vendor command area */ uint32_t vendor_cmd[0]; }; /* Response: */ struct fc_bsg_host_vendor_reply { /* start of vendor response area */ uint32_t vendor_rsp[0]; }; /* * FC Remote Port Messages */ /* FC_BSG_RPT_ELS : */ /* Request: * This message requests that an ELS be performed with the rport. */ struct fc_bsg_rport_els { /* * ELS Command Code being sent (must be the same as * byte 0 of the payload) */ uint8_t els_code; }; /* Response: * * The reply structure is an fc_bsg_ctels_reply structure */ /* FC_BSG_RPT_CT : */ /* Request: * This message requests that a CT Request be performed with the rport. */ struct fc_bsg_rport_ct { /* * We need words 0-2 of the generic preamble for the LLD's */ uint32_t preamble_word0; /* revision & IN_ID */ uint32_t preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */ uint32_t preamble_word2; /* Cmd Code, Max Size */ }; /* Response: * * The reply structure is an fc_bsg_ctels_reply structure */ /* request (CDB) structure of the sg_io_v4 */ struct fc_bsg_request { uint32_t msgcode; union { struct fc_bsg_host_add_rport h_addrport; struct fc_bsg_host_del_rport h_delrport; struct fc_bsg_host_els h_els; struct fc_bsg_host_ct h_ct; struct fc_bsg_host_vendor h_vendor; struct fc_bsg_rport_els r_els; struct fc_bsg_rport_ct r_ct; } rqst_data; } __attribute__((packed)); /* response (request sense data) structure of the sg_io_v4 */ struct fc_bsg_reply { /* * The completion result. Result exists in two forms: * if negative, it is an -Exxx system errno value. There will * be no further reply information supplied. * else, it's the 4-byte scsi error result, with driver, host, * msg and status fields. The per-msgcode reply structure * will contain valid data. */ uint32_t result; /* If there was reply_payload, how much was recevied ? */ uint32_t reply_payload_rcv_len; union { struct fc_bsg_host_vendor_reply vendor_reply; struct fc_bsg_ctels_reply ctels_reply; } reply_data; }; #endif /* SCSI_BSG_FC_H */ scsi/scsi.h000064400000015471152640040160006625 0ustar00/* Copyright (C) 1998-2018 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 . */ /* * This header file contains public constants and structures used by * the scsi code for linux. */ #ifndef _SCSI_SCSI_H #define _SCSI_SCSI_H 1 #include /* * SCSI opcodes */ #define TEST_UNIT_READY 0x00 #define REZERO_UNIT 0x01 #define REQUEST_SENSE 0x03 #define FORMAT_UNIT 0x04 #define READ_BLOCK_LIMITS 0x05 #define REASSIGN_BLOCKS 0x07 #define READ_6 0x08 #define WRITE_6 0x0a #define SEEK_6 0x0b #define READ_REVERSE 0x0f #define WRITE_FILEMARKS 0x10 #define SPACE 0x11 #define INQUIRY 0x12 #define RECOVER_BUFFERED_DATA 0x14 #define MODE_SELECT 0x15 #define RESERVE 0x16 #define RELEASE 0x17 #define COPY 0x18 #define ERASE 0x19 #define MODE_SENSE 0x1a #define START_STOP 0x1b #define RECEIVE_DIAGNOSTIC 0x1c #define SEND_DIAGNOSTIC 0x1d #define ALLOW_MEDIUM_REMOVAL 0x1e #define SET_WINDOW 0x24 #define READ_CAPACITY 0x25 #define READ_10 0x28 #define WRITE_10 0x2a #define SEEK_10 0x2b #define WRITE_VERIFY 0x2e #define VERIFY 0x2f #define SEARCH_HIGH 0x30 #define SEARCH_EQUAL 0x31 #define SEARCH_LOW 0x32 #define SET_LIMITS 0x33 #define PRE_FETCH 0x34 #define READ_POSITION 0x34 #define SYNCHRONIZE_CACHE 0x35 #define LOCK_UNLOCK_CACHE 0x36 #define READ_DEFECT_DATA 0x37 #define MEDIUM_SCAN 0x38 #define COMPARE 0x39 #define COPY_VERIFY 0x3a #define WRITE_BUFFER 0x3b #define READ_BUFFER 0x3c #define UPDATE_BLOCK 0x3d #define READ_LONG 0x3e #define WRITE_LONG 0x3f #define CHANGE_DEFINITION 0x40 #define WRITE_SAME 0x41 #define READ_TOC 0x43 #define LOG_SELECT 0x4c #define LOG_SENSE 0x4d #define MODE_SELECT_10 0x55 #define RESERVE_10 0x56 #define RELEASE_10 0x57 #define MODE_SENSE_10 0x5a #define PERSISTENT_RESERVE_IN 0x5e #define PERSISTENT_RESERVE_OUT 0x5f #define MOVE_MEDIUM 0xa5 #define READ_12 0xa8 #define WRITE_12 0xaa #define WRITE_VERIFY_12 0xae #define SEARCH_HIGH_12 0xb0 #define SEARCH_EQUAL_12 0xb1 #define SEARCH_LOW_12 0xb2 #define READ_ELEMENT_STATUS 0xb8 #define SEND_VOLUME_TAG 0xb6 #define WRITE_LONG_2 0xea /* * Status codes */ #define GOOD 0x00 #define CHECK_CONDITION 0x01 #define CONDITION_GOOD 0x02 #define BUSY 0x04 #define INTERMEDIATE_GOOD 0x08 #define INTERMEDIATE_C_GOOD 0x0a #define RESERVATION_CONFLICT 0x0c #define COMMAND_TERMINATED 0x11 #define QUEUE_FULL 0x14 #define STATUS_MASK 0x3e /* * SENSE KEYS */ #define NO_SENSE 0x00 #define RECOVERED_ERROR 0x01 #define NOT_READY 0x02 #define MEDIUM_ERROR 0x03 #define HARDWARE_ERROR 0x04 #define ILLEGAL_REQUEST 0x05 #define UNIT_ATTENTION 0x06 #define DATA_PROTECT 0x07 #define BLANK_CHECK 0x08 #define COPY_ABORTED 0x0a #define ABORTED_COMMAND 0x0b #define VOLUME_OVERFLOW 0x0d #define MISCOMPARE 0x0e /* * DEVICE TYPES */ #define TYPE_DISK 0x00 #define TYPE_TAPE 0x01 #define TYPE_PROCESSOR 0x03 /* HP scanners use this */ #define TYPE_WORM 0x04 /* Treated as ROM by our system */ #define TYPE_ROM 0x05 #define TYPE_SCANNER 0x06 #define TYPE_MOD 0x07 /* Magneto-optical disk - * - treated as TYPE_DISK */ #define TYPE_MEDIUM_CHANGER 0x08 #define TYPE_ENCLOSURE 0x0d /* Enclosure Services Device */ #define TYPE_NO_LUN 0x7f /* * standard mode-select header prepended to all mode-select commands * * moved here from cdrom.h -- kraxel */ struct ccs_modesel_head { unsigned char _r1; /* reserved. */ unsigned char medium; /* device-specific medium type. */ unsigned char _r2; /* reserved. */ unsigned char block_desc_length; /* block descriptor length. */ unsigned char density; /* device-specific density code. */ unsigned char number_blocks_hi; /* number of blocks in this block desc. */ unsigned char number_blocks_med; unsigned char number_blocks_lo; unsigned char _r3; unsigned char block_length_hi; /* block length for blocks in this desc. */ unsigned char block_length_med; unsigned char block_length_lo; }; /* * MESSAGE CODES */ #define COMMAND_COMPLETE 0x00 #define EXTENDED_MESSAGE 0x01 #define EXTENDED_MODIFY_DATA_POINTER 0x00 #define EXTENDED_SDTR 0x01 #define EXTENDED_EXTENDED_IDENTIFY 0x02 /* SCSI-I only */ #define EXTENDED_WDTR 0x03 #define SAVE_POINTERS 0x02 #define RESTORE_POINTERS 0x03 #define DISCONNECT 0x04 #define INITIATOR_ERROR 0x05 #define ABORT 0x06 #define MESSAGE_REJECT 0x07 #define NOP 0x08 #define MSG_PARITY_ERROR 0x09 #define LINKED_CMD_COMPLETE 0x0a #define LINKED_FLG_CMD_COMPLETE 0x0b #define BUS_DEVICE_RESET 0x0c #define INITIATE_RECOVERY 0x0f /* SCSI-II only */ #define RELEASE_RECOVERY 0x10 /* SCSI-II only */ #define SIMPLE_QUEUE_TAG 0x20 #define HEAD_OF_QUEUE_TAG 0x21 #define ORDERED_QUEUE_TAG 0x22 /* * Here are some scsi specific ioctl commands which are sometimes useful. */ /* These are a few other constants only used by scsi devices. */ #define SCSI_IOCTL_GET_IDLUN 0x5382 /* Used to turn on and off tagged queuing for scsi devices. */ #define SCSI_IOCTL_TAGGED_ENABLE 0x5383 #define SCSI_IOCTL_TAGGED_DISABLE 0x5384 /* Used to obtain the host number of a device. */ #define SCSI_IOCTL_PROBE_HOST 0x5385 /* Used to get the bus number for a device. */ #define SCSI_IOCTL_GET_BUS_NUMBER 0x5386 #endif /* scsi/scsi.h */ c++/8/cmath000064400000136016152640040160006307 0ustar00// -*- C++ -*- C forwarding header. // Copyright (C) 1997-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/cmath * This is a Standard C++ Library file. You should @c \#include this file * in your programs, rather than any of the @a *.h implementation files. * * This is the C++ version of the Standard C Library header @c math.h, * and its contents are (mostly) the same as that header, but are all * contained in the namespace @c std (except for names which are defined * as macros in C). */ // // ISO C++ 14882: 26.5 C library // #pragma GCC system_header #include #include #include #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS #include_next #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS #include #ifndef _GLIBCXX_CMATH #define _GLIBCXX_CMATH 1 // Get rid of those macros defined in in lieu of real functions. #undef div #undef acos #undef asin #undef atan #undef atan2 #undef ceil #undef cos #undef cosh #undef exp #undef fabs #undef floor #undef fmod #undef frexp #undef ldexp #undef log #undef log10 #undef modf #undef pow #undef sin #undef sinh #undef sqrt #undef tan #undef tanh extern "C++" { namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION using ::acos; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float acos(float __x) { return __builtin_acosf(__x); } inline _GLIBCXX_CONSTEXPR long double acos(long double __x) { return __builtin_acosl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type acos(_Tp __x) { return __builtin_acos(__x); } using ::asin; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float asin(float __x) { return __builtin_asinf(__x); } inline _GLIBCXX_CONSTEXPR long double asin(long double __x) { return __builtin_asinl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type asin(_Tp __x) { return __builtin_asin(__x); } using ::atan; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float atan(float __x) { return __builtin_atanf(__x); } inline _GLIBCXX_CONSTEXPR long double atan(long double __x) { return __builtin_atanl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type atan(_Tp __x) { return __builtin_atan(__x); } using ::atan2; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float atan2(float __y, float __x) { return __builtin_atan2f(__y, __x); } inline _GLIBCXX_CONSTEXPR long double atan2(long double __y, long double __x) { return __builtin_atan2l(__y, __x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__promote_2<_Tp, _Up>::__type atan2(_Tp __y, _Up __x) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return atan2(__type(__y), __type(__x)); } using ::ceil; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float ceil(float __x) { return __builtin_ceilf(__x); } inline _GLIBCXX_CONSTEXPR long double ceil(long double __x) { return __builtin_ceill(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type ceil(_Tp __x) { return __builtin_ceil(__x); } using ::cos; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float cos(float __x) { return __builtin_cosf(__x); } inline _GLIBCXX_CONSTEXPR long double cos(long double __x) { return __builtin_cosl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cos(_Tp __x) { return __builtin_cos(__x); } using ::cosh; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float cosh(float __x) { return __builtin_coshf(__x); } inline _GLIBCXX_CONSTEXPR long double cosh(long double __x) { return __builtin_coshl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cosh(_Tp __x) { return __builtin_cosh(__x); } using ::exp; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float exp(float __x) { return __builtin_expf(__x); } inline _GLIBCXX_CONSTEXPR long double exp(long double __x) { return __builtin_expl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type exp(_Tp __x) { return __builtin_exp(__x); } using ::fabs; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float fabs(float __x) { return __builtin_fabsf(__x); } inline _GLIBCXX_CONSTEXPR long double fabs(long double __x) { return __builtin_fabsl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type fabs(_Tp __x) { return __builtin_fabs(__x); } using ::floor; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float floor(float __x) { return __builtin_floorf(__x); } inline _GLIBCXX_CONSTEXPR long double floor(long double __x) { return __builtin_floorl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type floor(_Tp __x) { return __builtin_floor(__x); } using ::fmod; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float fmod(float __x, float __y) { return __builtin_fmodf(__x, __y); } inline _GLIBCXX_CONSTEXPR long double fmod(long double __x, long double __y) { return __builtin_fmodl(__x, __y); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmod(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmod(__type(__x), __type(__y)); } using ::frexp; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline float frexp(float __x, int* __exp) { return __builtin_frexpf(__x, __exp); } inline long double frexp(long double __x, int* __exp) { return __builtin_frexpl(__x, __exp); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type frexp(_Tp __x, int* __exp) { return __builtin_frexp(__x, __exp); } using ::ldexp; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float ldexp(float __x, int __exp) { return __builtin_ldexpf(__x, __exp); } inline _GLIBCXX_CONSTEXPR long double ldexp(long double __x, int __exp) { return __builtin_ldexpl(__x, __exp); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type ldexp(_Tp __x, int __exp) { return __builtin_ldexp(__x, __exp); } using ::log; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float log(float __x) { return __builtin_logf(__x); } inline _GLIBCXX_CONSTEXPR long double log(long double __x) { return __builtin_logl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log(_Tp __x) { return __builtin_log(__x); } using ::log10; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float log10(float __x) { return __builtin_log10f(__x); } inline _GLIBCXX_CONSTEXPR long double log10(long double __x) { return __builtin_log10l(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log10(_Tp __x) { return __builtin_log10(__x); } using ::modf; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline float modf(float __x, float* __iptr) { return __builtin_modff(__x, __iptr); } inline long double modf(long double __x, long double* __iptr) { return __builtin_modfl(__x, __iptr); } #endif using ::pow; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float pow(float __x, float __y) { return __builtin_powf(__x, __y); } inline _GLIBCXX_CONSTEXPR long double pow(long double __x, long double __y) { return __builtin_powl(__x, __y); } #if __cplusplus < 201103L // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 550. What should the return type of pow(float,int) be? inline double pow(double __x, int __i) { return __builtin_powi(__x, __i); } inline float pow(float __x, int __n) { return __builtin_powif(__x, __n); } inline long double pow(long double __x, int __n) { return __builtin_powil(__x, __n); } #endif #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return pow(__type(__x), __type(__y)); } using ::sin; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float sin(float __x) { return __builtin_sinf(__x); } inline _GLIBCXX_CONSTEXPR long double sin(long double __x) { return __builtin_sinl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sin(_Tp __x) { return __builtin_sin(__x); } using ::sinh; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float sinh(float __x) { return __builtin_sinhf(__x); } inline _GLIBCXX_CONSTEXPR long double sinh(long double __x) { return __builtin_sinhl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sinh(_Tp __x) { return __builtin_sinh(__x); } using ::sqrt; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float sqrt(float __x) { return __builtin_sqrtf(__x); } inline _GLIBCXX_CONSTEXPR long double sqrt(long double __x) { return __builtin_sqrtl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sqrt(_Tp __x) { return __builtin_sqrt(__x); } using ::tan; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float tan(float __x) { return __builtin_tanf(__x); } inline _GLIBCXX_CONSTEXPR long double tan(long double __x) { return __builtin_tanl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tan(_Tp __x) { return __builtin_tan(__x); } using ::tanh; #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO inline _GLIBCXX_CONSTEXPR float tanh(float __x) { return __builtin_tanhf(__x); } inline _GLIBCXX_CONSTEXPR long double tanh(long double __x) { return __builtin_tanhl(__x); } #endif template inline _GLIBCXX_CONSTEXPR typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tanh(_Tp __x) { return __builtin_tanh(__x); } #if _GLIBCXX_USE_C99_MATH #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC // These are possible macros imported from C99-land. #undef fpclassify #undef isfinite #undef isinf #undef isnan #undef isnormal #undef signbit #undef isgreater #undef isgreaterequal #undef isless #undef islessequal #undef islessgreater #undef isunordered #if __cplusplus >= 201103L #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr int fpclassify(float __x) { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x); } constexpr int fpclassify(double __x) { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x); } constexpr int fpclassify(long double __x) { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, int>::__type fpclassify(_Tp __x) { return __x != 0 ? FP_NORMAL : FP_ZERO; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isfinite(float __x) { return __builtin_isfinite(__x); } constexpr bool isfinite(double __x) { return __builtin_isfinite(__x); } constexpr bool isfinite(long double __x) { return __builtin_isfinite(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isfinite(_Tp __x) { return true; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isinf(float __x) { return __builtin_isinf(__x); } #if _GLIBCXX_HAVE_OBSOLETE_ISINF \ && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC using ::isinf; #else constexpr bool isinf(double __x) { return __builtin_isinf(__x); } #endif constexpr bool isinf(long double __x) { return __builtin_isinf(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isinf(_Tp __x) { return false; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isnan(float __x) { return __builtin_isnan(__x); } #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \ && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC using ::isnan; #else constexpr bool isnan(double __x) { return __builtin_isnan(__x); } #endif constexpr bool isnan(long double __x) { return __builtin_isnan(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isnan(_Tp __x) { return false; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isnormal(float __x) { return __builtin_isnormal(__x); } constexpr bool isnormal(double __x) { return __builtin_isnormal(__x); } constexpr bool isnormal(long double __x) { return __builtin_isnormal(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isnormal(_Tp __x) { return __x != 0 ? true : false; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic. constexpr bool signbit(float __x) { return __builtin_signbit(__x); } constexpr bool signbit(double __x) { return __builtin_signbit(__x); } constexpr bool signbit(long double __x) { return __builtin_signbit(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type signbit(_Tp __x) { return __x < 0 ? true : false; } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isgreater(float __x, float __y) { return __builtin_isgreater(__x, __y); } constexpr bool isgreater(double __x, double __y) { return __builtin_isgreater(__x, __y); } constexpr bool isgreater(long double __x, long double __y) { return __builtin_isgreater(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isgreater(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isgreater(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isgreaterequal(float __x, float __y) { return __builtin_isgreaterequal(__x, __y); } constexpr bool isgreaterequal(double __x, double __y) { return __builtin_isgreaterequal(__x, __y); } constexpr bool isgreaterequal(long double __x, long double __y) { return __builtin_isgreaterequal(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isgreaterequal(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isgreaterequal(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isless(float __x, float __y) { return __builtin_isless(__x, __y); } constexpr bool isless(double __x, double __y) { return __builtin_isless(__x, __y); } constexpr bool isless(long double __x, long double __y) { return __builtin_isless(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isless(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isless(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool islessequal(float __x, float __y) { return __builtin_islessequal(__x, __y); } constexpr bool islessequal(double __x, double __y) { return __builtin_islessequal(__x, __y); } constexpr bool islessequal(long double __x, long double __y) { return __builtin_islessequal(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type islessequal(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_islessequal(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool islessgreater(float __x, float __y) { return __builtin_islessgreater(__x, __y); } constexpr bool islessgreater(double __x, double __y) { return __builtin_islessgreater(__x, __y); } constexpr bool islessgreater(long double __x, long double __y) { return __builtin_islessgreater(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type islessgreater(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_islessgreater(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr bool isunordered(float __x, float __y) { return __builtin_isunordered(__x, __y); } constexpr bool isunordered(double __x, double __y) { return __builtin_isunordered(__x, __y); } constexpr bool isunordered(long double __x, long double __y) { return __builtin_isunordered(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isunordered(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isunordered(__type(__x), __type(__y)); } #endif #else template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type fpclassify(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isfinite(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isfinite(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isinf(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isinf(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isnan(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isnan(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isnormal(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isnormal(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type signbit(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_signbit(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isgreater(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isgreater(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isgreaterequal(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isgreaterequal(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isless(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isless(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type islessequal(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_islessequal(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type islessgreater(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_islessgreater(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isunordered(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isunordered(__type(__f1), __type(__f2)); } #endif // C++11 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ #endif /* _GLIBCXX_USE_C99_MATH */ #if __cplusplus >= 201103L #ifdef _GLIBCXX_USE_C99_MATH_TR1 #undef acosh #undef acoshf #undef acoshl #undef asinh #undef asinhf #undef asinhl #undef atanh #undef atanhf #undef atanhl #undef cbrt #undef cbrtf #undef cbrtl #undef copysign #undef copysignf #undef copysignl #undef erf #undef erff #undef erfl #undef erfc #undef erfcf #undef erfcl #undef exp2 #undef exp2f #undef exp2l #undef expm1 #undef expm1f #undef expm1l #undef fdim #undef fdimf #undef fdiml #undef fma #undef fmaf #undef fmal #undef fmax #undef fmaxf #undef fmaxl #undef fmin #undef fminf #undef fminl #undef hypot #undef hypotf #undef hypotl #undef ilogb #undef ilogbf #undef ilogbl #undef lgamma #undef lgammaf #undef lgammal #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS #undef llrint #undef llrintf #undef llrintl #undef llround #undef llroundf #undef llroundl #endif #undef log1p #undef log1pf #undef log1pl #undef log2 #undef log2f #undef log2l #undef logb #undef logbf #undef logbl #undef lrint #undef lrintf #undef lrintl #undef lround #undef lroundf #undef lroundl #undef nan #undef nanf #undef nanl #undef nearbyint #undef nearbyintf #undef nearbyintl #undef nextafter #undef nextafterf #undef nextafterl #undef nexttoward #undef nexttowardf #undef nexttowardl #undef remainder #undef remainderf #undef remainderl #undef remquo #undef remquof #undef remquol #undef rint #undef rintf #undef rintl #undef round #undef roundf #undef roundl #undef scalbln #undef scalblnf #undef scalblnl #undef scalbn #undef scalbnf #undef scalbnl #undef tgamma #undef tgammaf #undef tgammal #undef trunc #undef truncf #undef truncl // types using ::double_t; using ::float_t; // functions using ::acosh; using ::acoshf; using ::acoshl; using ::asinh; using ::asinhf; using ::asinhl; using ::atanh; using ::atanhf; using ::atanhl; using ::cbrt; using ::cbrtf; using ::cbrtl; using ::copysign; using ::copysignf; using ::copysignl; using ::erf; using ::erff; using ::erfl; using ::erfc; using ::erfcf; using ::erfcl; using ::exp2; using ::exp2f; using ::exp2l; using ::expm1; using ::expm1f; using ::expm1l; using ::fdim; using ::fdimf; using ::fdiml; using ::fma; using ::fmaf; using ::fmal; using ::fmax; using ::fmaxf; using ::fmaxl; using ::fmin; using ::fminf; using ::fminl; using ::hypot; using ::hypotf; using ::hypotl; using ::ilogb; using ::ilogbf; using ::ilogbl; using ::lgamma; using ::lgammaf; using ::lgammal; #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS using ::llrint; using ::llrintf; using ::llrintl; using ::llround; using ::llroundf; using ::llroundl; #endif using ::log1p; using ::log1pf; using ::log1pl; using ::log2; using ::log2f; using ::log2l; using ::logb; using ::logbf; using ::logbl; using ::lrint; using ::lrintf; using ::lrintl; using ::lround; using ::lroundf; using ::lroundl; using ::nan; using ::nanf; using ::nanl; using ::nearbyint; using ::nearbyintf; using ::nearbyintl; using ::nextafter; using ::nextafterf; using ::nextafterl; using ::nexttoward; using ::nexttowardf; using ::nexttowardl; using ::remainder; using ::remainderf; using ::remainderl; using ::remquo; using ::remquof; using ::remquol; using ::rint; using ::rintf; using ::rintl; using ::round; using ::roundf; using ::roundl; using ::scalbln; using ::scalblnf; using ::scalblnl; using ::scalbn; using ::scalbnf; using ::scalbnl; using ::tgamma; using ::tgammaf; using ::tgammal; using ::trunc; using ::truncf; using ::truncl; /// Additional overloads. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float acosh(float __x) { return __builtin_acoshf(__x); } constexpr long double acosh(long double __x) { return __builtin_acoshl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type acosh(_Tp __x) { return __builtin_acosh(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float asinh(float __x) { return __builtin_asinhf(__x); } constexpr long double asinh(long double __x) { return __builtin_asinhl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type asinh(_Tp __x) { return __builtin_asinh(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float atanh(float __x) { return __builtin_atanhf(__x); } constexpr long double atanh(long double __x) { return __builtin_atanhl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type atanh(_Tp __x) { return __builtin_atanh(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float cbrt(float __x) { return __builtin_cbrtf(__x); } constexpr long double cbrt(long double __x) { return __builtin_cbrtl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cbrt(_Tp __x) { return __builtin_cbrt(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float copysign(float __x, float __y) { return __builtin_copysignf(__x, __y); } constexpr long double copysign(long double __x, long double __y) { return __builtin_copysignl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type copysign(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return copysign(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float erf(float __x) { return __builtin_erff(__x); } constexpr long double erf(long double __x) { return __builtin_erfl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erf(_Tp __x) { return __builtin_erf(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float erfc(float __x) { return __builtin_erfcf(__x); } constexpr long double erfc(long double __x) { return __builtin_erfcl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erfc(_Tp __x) { return __builtin_erfc(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float exp2(float __x) { return __builtin_exp2f(__x); } constexpr long double exp2(long double __x) { return __builtin_exp2l(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type exp2(_Tp __x) { return __builtin_exp2(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float expm1(float __x) { return __builtin_expm1f(__x); } constexpr long double expm1(long double __x) { return __builtin_expm1l(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type expm1(_Tp __x) { return __builtin_expm1(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float fdim(float __x, float __y) { return __builtin_fdimf(__x, __y); } constexpr long double fdim(long double __x, long double __y) { return __builtin_fdiml(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fdim(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fdim(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float fma(float __x, float __y, float __z) { return __builtin_fmaf(__x, __y, __z); } constexpr long double fma(long double __x, long double __y, long double __z) { return __builtin_fmal(__x, __y, __z); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type fma(_Tp __x, _Up __y, _Vp __z) { typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; return fma(__type(__x), __type(__y), __type(__z)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float fmax(float __x, float __y) { return __builtin_fmaxf(__x, __y); } constexpr long double fmax(long double __x, long double __y) { return __builtin_fmaxl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmax(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmax(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float fmin(float __x, float __y) { return __builtin_fminf(__x, __y); } constexpr long double fmin(long double __x, long double __y) { return __builtin_fminl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmin(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmin(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float hypot(float __x, float __y) { return __builtin_hypotf(__x, __y); } constexpr long double hypot(long double __x, long double __y) { return __builtin_hypotl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type hypot(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return hypot(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr int ilogb(float __x) { return __builtin_ilogbf(__x); } constexpr int ilogb(long double __x) { return __builtin_ilogbl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, int>::__type ilogb(_Tp __x) { return __builtin_ilogb(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float lgamma(float __x) { return __builtin_lgammaf(__x); } constexpr long double lgamma(long double __x) { return __builtin_lgammal(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type lgamma(_Tp __x) { return __builtin_lgamma(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr long long llrint(float __x) { return __builtin_llrintf(__x); } constexpr long long llrint(long double __x) { return __builtin_llrintl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llrint(_Tp __x) { return __builtin_llrint(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr long long llround(float __x) { return __builtin_llroundf(__x); } constexpr long long llround(long double __x) { return __builtin_llroundl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llround(_Tp __x) { return __builtin_llround(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float log1p(float __x) { return __builtin_log1pf(__x); } constexpr long double log1p(long double __x) { return __builtin_log1pl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log1p(_Tp __x) { return __builtin_log1p(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP // DR 568. constexpr float log2(float __x) { return __builtin_log2f(__x); } constexpr long double log2(long double __x) { return __builtin_log2l(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log2(_Tp __x) { return __builtin_log2(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float logb(float __x) { return __builtin_logbf(__x); } constexpr long double logb(long double __x) { return __builtin_logbl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type logb(_Tp __x) { return __builtin_logb(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr long lrint(float __x) { return __builtin_lrintf(__x); } constexpr long lrint(long double __x) { return __builtin_lrintl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lrint(_Tp __x) { return __builtin_lrint(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr long lround(float __x) { return __builtin_lroundf(__x); } constexpr long lround(long double __x) { return __builtin_lroundl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lround(_Tp __x) { return __builtin_lround(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float nearbyint(float __x) { return __builtin_nearbyintf(__x); } constexpr long double nearbyint(long double __x) { return __builtin_nearbyintl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nearbyint(_Tp __x) { return __builtin_nearbyint(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float nextafter(float __x, float __y) { return __builtin_nextafterf(__x, __y); } constexpr long double nextafter(long double __x, long double __y) { return __builtin_nextafterl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type nextafter(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return nextafter(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float nexttoward(float __x, long double __y) { return __builtin_nexttowardf(__x, __y); } constexpr long double nexttoward(long double __x, long double __y) { return __builtin_nexttowardl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nexttoward(_Tp __x, long double __y) { return __builtin_nexttoward(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float remainder(float __x, float __y) { return __builtin_remainderf(__x, __y); } constexpr long double remainder(long double __x, long double __y) { return __builtin_remainderl(__x, __y); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remainder(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remainder(__type(__x), __type(__y)); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float remquo(float __x, float __y, int* __pquo) { return __builtin_remquof(__x, __y, __pquo); } inline long double remquo(long double __x, long double __y, int* __pquo) { return __builtin_remquol(__x, __y, __pquo); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remquo(_Tp __x, _Up __y, int* __pquo) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remquo(__type(__x), __type(__y), __pquo); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float rint(float __x) { return __builtin_rintf(__x); } constexpr long double rint(long double __x) { return __builtin_rintl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type rint(_Tp __x) { return __builtin_rint(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float round(float __x) { return __builtin_roundf(__x); } constexpr long double round(long double __x) { return __builtin_roundl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type round(_Tp __x) { return __builtin_round(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float scalbln(float __x, long __ex) { return __builtin_scalblnf(__x, __ex); } constexpr long double scalbln(long double __x, long __ex) { return __builtin_scalblnl(__x, __ex); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbln(_Tp __x, long __ex) { return __builtin_scalbln(__x, __ex); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float scalbn(float __x, int __ex) { return __builtin_scalbnf(__x, __ex); } constexpr long double scalbn(long double __x, int __ex) { return __builtin_scalbnl(__x, __ex); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbn(_Tp __x, int __ex) { return __builtin_scalbn(__x, __ex); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float tgamma(float __x) { return __builtin_tgammaf(__x); } constexpr long double tgamma(long double __x) { return __builtin_tgammal(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tgamma(_Tp __x) { return __builtin_tgamma(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP constexpr float trunc(float __x) { return __builtin_truncf(__x); } constexpr long double trunc(long double __x) { return __builtin_truncl(__x); } #endif #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type trunc(_Tp __x) { return __builtin_trunc(__x); } #endif #endif // _GLIBCXX_USE_C99_MATH_TR1 #endif // C++11 #if __cplusplus > 201402L // [c.math.hypot3], three-dimensional hypotenuse #define __cpp_lib_hypot 201603 template inline _Tp __hypot3(_Tp __x, _Tp __y, _Tp __z) { __x = std::abs(__x); __y = std::abs(__y); __z = std::abs(__z); if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) return __a * std::sqrt((__x / __a) * (__x / __a) + (__y / __a) * (__y / __a) + (__z / __a) * (__z / __a)); else return {}; } inline float hypot(float __x, float __y, float __z) { return std::__hypot3(__x, __y, __z); } inline double hypot(double __x, double __y, double __z) { return std::__hypot3(__x, __y, __z); } inline long double hypot(long double __x, long double __y, long double __z) { return std::__hypot3(__x, __y, __z); } template typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type hypot(_Tp __x, _Up __y, _Vp __z) { using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type; return std::__hypot3<__type>(__x, __y, __z); } #endif // C++17 _GLIBCXX_END_NAMESPACE_VERSION } // namespace #if _GLIBCXX_USE_STD_SPEC_FUNCS # include #endif } // extern "C++" #endif c++/8/condition_variable000064400000021372152640040160011044 0ustar00// -*- C++ -*- // Copyright (C) 2008-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/condition_variable * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_CONDITION_VARIABLE #define _GLIBCXX_CONDITION_VARIABLE 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include #include #include #include #include #include #include #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @defgroup condition_variables Condition Variables * @ingroup concurrency * * Classes for condition_variable support. * @{ */ /// cv_status enum class cv_status { no_timeout, timeout }; /// condition_variable class condition_variable { typedef chrono::system_clock __clock_t; typedef __gthread_cond_t __native_type; #ifdef __GTHREAD_COND_INIT __native_type _M_cond = __GTHREAD_COND_INIT; #else __native_type _M_cond; #endif public: typedef __native_type* native_handle_type; condition_variable() noexcept; ~condition_variable() noexcept; condition_variable(const condition_variable&) = delete; condition_variable& operator=(const condition_variable&) = delete; void notify_one() noexcept; void notify_all() noexcept; void wait(unique_lock& __lock) noexcept; template void wait(unique_lock& __lock, _Predicate __p) { while (!__p()) wait(__lock); } template cv_status wait_until(unique_lock& __lock, const chrono::time_point<__clock_t, _Duration>& __atime) { return __wait_until_impl(__lock, __atime); } template cv_status wait_until(unique_lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime) { // DR 887 - Sync unknown clock to known clock. const typename _Clock::time_point __c_entry = _Clock::now(); const __clock_t::time_point __s_entry = __clock_t::now(); const auto __delta = __atime - __c_entry; const auto __s_atime = __s_entry + __delta; return __wait_until_impl(__lock, __s_atime); } template bool wait_until(unique_lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime, _Predicate __p) { while (!__p()) if (wait_until(__lock, __atime) == cv_status::timeout) return __p(); return true; } template cv_status wait_for(unique_lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) { using __dur = typename __clock_t::duration; auto __reltime = chrono::duration_cast<__dur>(__rtime); if (__reltime < __rtime) ++__reltime; return wait_until(__lock, __clock_t::now() + __reltime); } template bool wait_for(unique_lock& __lock, const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) { using __dur = typename __clock_t::duration; auto __reltime = chrono::duration_cast<__dur>(__rtime); if (__reltime < __rtime) ++__reltime; return wait_until(__lock, __clock_t::now() + __reltime, std::move(__p)); } native_handle_type native_handle() { return &_M_cond; } private: template cv_status __wait_until_impl(unique_lock& __lock, const chrono::time_point<__clock_t, _Dur>& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(), &__ts); return (__clock_t::now() < __atime ? cv_status::no_timeout : cv_status::timeout); } }; void notify_all_at_thread_exit(condition_variable&, unique_lock); struct __at_thread_exit_elt { __at_thread_exit_elt* _M_next; void (*_M_cb)(void*); }; inline namespace _V2 { /// condition_variable_any // Like above, but mutex is not required to have try_lock. class condition_variable_any { typedef chrono::system_clock __clock_t; condition_variable _M_cond; shared_ptr _M_mutex; // scoped unlock - unlocks in ctor, re-locks in dtor template struct _Unlock { explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); } ~_Unlock() noexcept(false) { if (uncaught_exception()) { __try { _M_lock.lock(); } __catch(const __cxxabiv1::__forced_unwind&) { __throw_exception_again; } __catch(...) { } } else _M_lock.lock(); } _Unlock(const _Unlock&) = delete; _Unlock& operator=(const _Unlock&) = delete; _Lock& _M_lock; }; public: condition_variable_any() : _M_mutex(std::make_shared()) { } ~condition_variable_any() = default; condition_variable_any(const condition_variable_any&) = delete; condition_variable_any& operator=(const condition_variable_any&) = delete; void notify_one() noexcept { lock_guard __lock(*_M_mutex); _M_cond.notify_one(); } void notify_all() noexcept { lock_guard __lock(*_M_mutex); _M_cond.notify_all(); } template void wait(_Lock& __lock) { shared_ptr __mutex = _M_mutex; unique_lock __my_lock(*__mutex); _Unlock<_Lock> __unlock(__lock); // *__mutex must be unlocked before re-locking __lock so move // ownership of *__mutex lock to an object with shorter lifetime. unique_lock __my_lock2(std::move(__my_lock)); _M_cond.wait(__my_lock2); } template void wait(_Lock& __lock, _Predicate __p) { while (!__p()) wait(__lock); } template cv_status wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime) { shared_ptr __mutex = _M_mutex; unique_lock __my_lock(*__mutex); _Unlock<_Lock> __unlock(__lock); // *__mutex must be unlocked before re-locking __lock so move // ownership of *__mutex lock to an object with shorter lifetime. unique_lock __my_lock2(std::move(__my_lock)); return _M_cond.wait_until(__my_lock2, __atime); } template bool wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime, _Predicate __p) { while (!__p()) if (wait_until(__lock, __atime) == cv_status::timeout) return __p(); return true; } template cv_status wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) { return wait_until(__lock, __clock_t::now() + __rtime); } template bool wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } }; } // end inline namespace // @} group condition_variables _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 #endif // C++11 #endif // _GLIBCXX_CONDITION_VARIABLE c++/8/utility000064400000030017152640040160006710 0ustar00// -*- C++ -*- // Copyright (C) 2001-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1996,1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /** @file include/utility * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_UTILITY #define _GLIBCXX_UTILITY 1 #pragma GCC system_header /** * @defgroup utilities Utilities * * Components deemed generally useful. Includes pair, tuple, * forward/move helpers, ratio, function object, metaprogramming and * type traits, time, date, and memory functions. */ #include #include #include #if __cplusplus >= 201103L #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Finds the size of a given tuple type. template struct tuple_size; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2313. tuple_size should always derive from integral_constant // 2770. tuple_size specialization is not SFINAE compatible template::type, typename = typename enable_if::value>::type, size_t = tuple_size<_Tp>::value> using __enable_if_has_tuple_size = _Tp; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; /// Gives the type of the ith element of a given tuple type. template struct tuple_element; // Duplicate of C++14's tuple_element_t for internal use in C++11 mode template using __tuple_element_t = typename tuple_element<__i, _Tp>::type; template struct tuple_element<__i, const _Tp> { typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; }; template struct tuple_element<__i, volatile _Tp> { typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; }; template struct tuple_element<__i, const volatile _Tp> { typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; }; #if __cplusplus > 201103L #define __cpp_lib_tuple_element_t 201402 template using tuple_element_t = typename tuple_element<__i, _Tp>::type; #endif // Various functions which give std::pair a tuple-like interface. /// Partial specialization for std::pair template struct __is_tuple_like_impl> : true_type { }; /// Partial specialization for std::pair template struct tuple_size> : public integral_constant { }; /// Partial specialization for std::pair template struct tuple_element<0, std::pair<_Tp1, _Tp2>> { typedef _Tp1 type; }; /// Partial specialization for std::pair template struct tuple_element<1, std::pair<_Tp1, _Tp2>> { typedef _Tp2 type; }; template struct __pair_get; template<> struct __pair_get<0> { template static constexpr _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr _Tp1&& __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp1>(__pair.first); } template static constexpr const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr const _Tp1&& __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.first); } }; template<> struct __pair_get<1> { template static constexpr _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr _Tp2&& __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp2>(__pair.second); } template static constexpr const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr const _Tp2&& __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.second); } }; template constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& get(std::pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__get(__in); } template constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& get(std::pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__move_get(std::move(__in)); } template constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& get(const std::pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__const_get(__in); } template constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& get(const std::pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__const_move_get(std::move(__in)); } #if __cplusplus > 201103L #define __cpp_lib_tuples_by_type 201304 template constexpr _Tp& get(pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr const _Tp& get(const pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr _Tp&& get(pair<_Tp, _Up>&& __p) noexcept { return std::move(__p.first); } template constexpr const _Tp&& get(const pair<_Tp, _Up>&& __p) noexcept { return std::move(__p.first); } template constexpr _Tp& get(pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr const _Tp& get(const pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr _Tp&& get(pair<_Up, _Tp>&& __p) noexcept { return std::move(__p.second); } template constexpr const _Tp&& get(const pair<_Up, _Tp>&& __p) noexcept { return std::move(__p.second); } #define __cpp_lib_exchange_function 201304 /// Assign @p __new_val to @p __obj and return its previous value. template inline _Tp exchange(_Tp& __obj, _Up&& __new_val) { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } #endif // Stores a tuple of indices. Used by tuple and pair, and by bind() to // extract the elements in a tuple. template struct _Index_tuple { }; #ifdef __has_builtin # if __has_builtin(__make_integer_seq) # define _GLIBCXX_USE_MAKE_INTEGER_SEQ 1 # endif #endif // Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. template struct _Build_index_tuple { #if _GLIBCXX_USE_MAKE_INTEGER_SEQ template using _IdxTuple = _Index_tuple<_Indices...>; using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; #else using __type = _Index_tuple<__integer_pack(_Num)...>; #endif }; #if __cplusplus > 201103L #define __cpp_lib_integer_sequence 201304 /// Class template integer_sequence template struct integer_sequence { typedef _Tp value_type; static constexpr size_t size() noexcept { return sizeof...(_Idx); } }; /// Alias template make_integer_sequence template using make_integer_sequence #if _GLIBCXX_USE_MAKE_INTEGER_SEQ = __make_integer_seq; #else = integer_sequence<_Tp, __integer_pack(_Num)...>; #endif #undef _GLIBCXX_USE_MAKE_INTEGER_SEQ /// Alias template index_sequence template using index_sequence = integer_sequence; /// Alias template make_index_sequence template using make_index_sequence = make_integer_sequence; /// Alias template index_sequence_for template using index_sequence_for = make_index_sequence; #endif #if __cplusplus > 201402L struct in_place_t { explicit in_place_t() = default; }; inline constexpr in_place_t in_place{}; template struct in_place_type_t { explicit in_place_type_t() = default; }; template inline constexpr in_place_type_t<_Tp> in_place_type{}; template struct in_place_index_t { explicit in_place_index_t() = default; }; template inline constexpr in_place_index_t<_Idx> in_place_index{}; template struct __is_in_place_type_impl : false_type { }; template struct __is_in_place_type_impl> : true_type { }; template struct __is_in_place_type : public __is_in_place_type_impl<_Tp> { }; #define __cpp_lib_as_const 201510 template constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; } template void as_const(const _Tp&&) = delete; #endif // C++17 _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif #endif /* _GLIBCXX_UTILITY */ c++/8/math.h000064400000010417152640040160006366 0ustar00// -*- C++ -*- compatibility header. // Copyright (C) 2002-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file math.h * This is a Standard C++ Library header. */ #if !defined __cplusplus || defined _GLIBCXX_INCLUDE_NEXT_C_HEADERS # include_next #else #ifndef _GLIBCXX_MATH_H #define _GLIBCXX_MATH_H 1 # include using std::abs; using std::acos; using std::asin; using std::atan; using std::atan2; using std::cos; using std::sin; using std::tan; using std::cosh; using std::sinh; using std::tanh; using std::exp; using std::frexp; using std::ldexp; using std::log; using std::log10; using std::modf; using std::pow; using std::sqrt; using std::ceil; using std::fabs; using std::floor; using std::fmod; #if _GLIBCXX_USE_C99_MATH using std::fpclassify; using std::isfinite; using std::isinf; using std::isnan; using std::isnormal; using std::signbit; using std::isgreater; using std::isgreaterequal; using std::isless; using std::islessequal; using std::islessgreater; using std::isunordered; #endif #if __cplusplus >= 201103L && defined(_GLIBCXX_USE_C99_MATH_TR1) using std::acosh; using std::asinh; using std::atanh; using std::cbrt; using std::copysign; using std::erf; using std::erfc; using std::exp2; using std::expm1; using std::fdim; using std::fma; using std::fmax; using std::fmin; using std::hypot; using std::ilogb; using std::lgamma; using std::llrint; using std::llround; using std::log1p; using std::log2; using std::logb; using std::lrint; using std::lround; using std::nearbyint; using std::nextafter; using std::nexttoward; using std::remainder; using std::remquo; using std::rint; using std::round; using std::scalbln; using std::scalbn; using std::tgamma; using std::trunc; #endif // C++11 && _GLIBCXX_USE_C99_MATH_TR1 #if _GLIBCXX_USE_STD_SPEC_FUNCS using std::assoc_laguerref; using std::assoc_laguerrel; using std::assoc_laguerre; using std::assoc_legendref; using std::assoc_legendrel; using std::assoc_legendre; using std::betaf; using std::betal; using std::beta; using std::comp_ellint_1f; using std::comp_ellint_1l; using std::comp_ellint_1; using std::comp_ellint_2f; using std::comp_ellint_2l; using std::comp_ellint_2; using std::comp_ellint_3f; using std::comp_ellint_3l; using std::comp_ellint_3; using std::cyl_bessel_if; using std::cyl_bessel_il; using std::cyl_bessel_i; using std::cyl_bessel_jf; using std::cyl_bessel_jl; using std::cyl_bessel_j; using std::cyl_bessel_kf; using std::cyl_bessel_kl; using std::cyl_bessel_k; using std::cyl_neumannf; using std::cyl_neumannl; using std::cyl_neumann; using std::ellint_1f; using std::ellint_1l; using std::ellint_1; using std::ellint_2f; using std::ellint_2l; using std::ellint_2; using std::ellint_3f; using std::ellint_3l; using std::ellint_3; using std::expintf; using std::expintl; using std::expint; using std::hermitef; using std::hermitel; using std::hermite; using std::laguerref; using std::laguerrel; using std::laguerre; using std::legendref; using std::legendrel; using std::legendre; using std::riemann_zetaf; using std::riemann_zetal; using std::riemann_zeta; using std::sph_besself; using std::sph_bessell; using std::sph_bessel; using std::sph_legendref; using std::sph_legendrel; using std::sph_legendre; using std::sph_neumannf; using std::sph_neumannl; using std::sph_neumann; #endif // _GLIBCXX_USE_STD_SPEC_FUNCS #endif // _GLIBCXX_MATH_H #endif // __cplusplus c++/8/optional000064400000125673152640040170007050 0ustar00// -*- C++ -*- // Copyright (C) 2013-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/optional * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_OPTIONAL #define _GLIBCXX_OPTIONAL 1 #pragma GCC system_header #if __cplusplus >= 201703L #include #include #include #include #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @addtogroup utilities * @{ */ #define __cpp_lib_optional 201606L template class optional; /// Tag type to disengage optional objects. struct nullopt_t { // Do not user-declare default constructor at all for // optional_value = {} syntax to work. // nullopt_t() = delete; // Used for constructing nullopt. enum class _Construct { _Token }; // Must be constexpr for nullopt_t to be literal. explicit constexpr nullopt_t(_Construct) { } }; /// Tag to disengage optional objects. inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; /** * @brief Exception class thrown when a disengaged optional object is * dereferenced. * @ingroup exceptions */ class bad_optional_access : public exception { public: bad_optional_access() { } virtual const char* what() const noexcept override { return "bad optional access"; } virtual ~bad_optional_access() noexcept = default; }; void __throw_bad_optional_access() __attribute__((__noreturn__)); // XXX Does not belong here. inline void __throw_bad_optional_access() { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); } // Payload for optionals with non-trivial destructor. template , bool /*_HasTrivialCopy */ = is_trivially_copy_assignable_v<_Tp> && is_trivially_copy_constructible_v<_Tp>, bool /*_HasTrivialMove */ = is_trivially_move_assignable_v<_Tp> && is_trivially_move_constructible_v<_Tp>> struct _Optional_payload { constexpr _Optional_payload() noexcept : _M_empty() { } template constexpr _Optional_payload(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload(bool __engaged, const _Optional_payload& __other) : _Optional_payload(__other) { } constexpr _Optional_payload(bool __engaged, _Optional_payload&& __other) : _Optional_payload(std::move(__other)) { } constexpr _Optional_payload(const _Optional_payload& __other) { if (__other._M_engaged) this->_M_construct(__other._M_payload); } constexpr _Optional_payload(_Optional_payload&& __other) { if (__other._M_engaged) this->_M_construct(std::move(__other._M_payload)); } constexpr _Optional_payload& operator=(const _Optional_payload& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } return *this; } constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_, is_nothrow_move_assignable<_Tp>>()) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } return *this; } using _Stored_type = remove_const_t<_Tp>; struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged = false; ~_Optional_payload() { if (_M_engaged) _M_payload.~_Stored_type(); } template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new ((void *) std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return this->_M_payload; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload; } // _M_reset is a 'safe' operation with no precondition. constexpr void _M_reset() noexcept { if (this->_M_engaged) { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } } }; // Payload for potentially-constexpr optionals. template struct _Optional_payload<_Tp, true, true, true> { constexpr _Optional_payload() noexcept : _M_empty(), _M_engaged(false) { } template constexpr _Optional_payload(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload(bool __engaged, const _Optional_payload& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(__other._M_get()); } constexpr _Optional_payload(bool __engaged, _Optional_payload&& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(std::move(__other._M_get())); } using _Stored_type = remove_const_t<_Tp>; struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged; // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return this->_M_payload; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload; } }; // Payload for optionals with non-trivial copy assignment. template struct _Optional_payload<_Tp, true, false, true> { constexpr _Optional_payload() noexcept : _M_empty(), _M_engaged(false) { } template constexpr _Optional_payload(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload(bool __engaged, const _Optional_payload& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(__other._M_get()); } constexpr _Optional_payload(bool __engaged, _Optional_payload&& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(std::move(__other._M_get())); } _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; constexpr _Optional_payload& operator=(const _Optional_payload& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } return *this; } _Optional_payload& operator=(_Optional_payload&& __other) = default; using _Stored_type = remove_const_t<_Tp>; struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged; template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new ((void *) std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return this->_M_payload; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload; } // _M_reset is a 'safe' operation with no precondition. constexpr void _M_reset() noexcept { if (this->_M_engaged) { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } } }; // Payload for optionals with non-trivial move assignment. template struct _Optional_payload<_Tp, true, true, false> { constexpr _Optional_payload() noexcept : _M_empty(), _M_engaged(false) { } template constexpr _Optional_payload(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload(bool __engaged, const _Optional_payload& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(__other._M_get()); } constexpr _Optional_payload(bool __engaged, _Optional_payload&& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(std::move(__other._M_get())); } _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(const _Optional_payload& __other) = default; constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_, is_nothrow_move_assignable<_Tp>>()) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } return *this; } using _Stored_type = remove_const_t<_Tp>; struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged; template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new ((void *) std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return this->_M_payload; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload; } // _M_reset is a 'safe' operation with no precondition. constexpr void _M_reset() noexcept { if (this->_M_engaged) { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } } }; // Payload for optionals with non-trivial copy and move assignment. template struct _Optional_payload<_Tp, true, false, false> { constexpr _Optional_payload() noexcept : _M_empty(), _M_engaged(false) {} template constexpr _Optional_payload(in_place_t, _Args&&... __args) : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload(bool __engaged, const _Optional_payload& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(__other._M_get()); } constexpr _Optional_payload(bool __engaged, _Optional_payload&& __other) : _M_engaged(__engaged) { if (__engaged) _M_construct(std::move(__other._M_get())); } _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; constexpr _Optional_payload& operator=(const _Optional_payload& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } return *this; } constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_, is_nothrow_move_assignable<_Tp>>()) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = std::move(__other._M_get()); else { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); else this->_M_reset(); } return *this; } using _Stored_type = remove_const_t<_Tp>; struct _Empty_byte { }; union { _Empty_byte _M_empty; _Stored_type _M_payload; }; bool _M_engaged; template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new ((void *) std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { return this->_M_payload; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload; } // _M_reset is a 'safe' operation with no precondition. constexpr void _M_reset() noexcept { if (this->_M_engaged) { this->_M_engaged = false; this->_M_payload.~_Stored_type(); } } }; template class _Optional_base_impl { protected: using _Stored_type = remove_const_t<_Tp>; // The _M_construct operation has !_M_engaged as a precondition // while _M_destruct has _M_engaged as a precondition. template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) { ::new (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload)) _Stored_type(std::forward<_Args>(__args)...); static_cast<_Dp*>(this)->_M_payload._M_engaged = true; } void _M_destruct() noexcept { static_cast<_Dp*>(this)->_M_payload._M_engaged = false; static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type(); } // _M_reset is a 'safe' operation with no precondition. constexpr void _M_reset() noexcept { if (static_cast<_Dp*>(this)->_M_payload._M_engaged) static_cast<_Dp*>(this)->_M_destruct(); } }; /** * @brief Class template that takes care of copy/move constructors of optional * * Such a separate base class template is necessary in order to * conditionally make copy/move constructors trivial. * @see optional, _Enable_special_members */ template, bool = is_trivially_move_constructible_v<_Tp>> class _Optional_base // protected inheritance because optional needs to reach that base too : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>> { friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>; public: // Constructors for disengaged optionals. constexpr _Optional_base() = default; // Constructors for engaged optionals. template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } // Copy and move constructors. constexpr _Optional_base(const _Optional_base& __other) : _M_payload(__other._M_payload._M_engaged, __other._M_payload) { } constexpr _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible<_Tp>()) : _M_payload(__other._M_payload._M_engaged, std::move(__other._M_payload)) { } // Assignment operators. _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_payload._M_engaged; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } constexpr const _Tp& _M_get() const noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } private: _Optional_payload<_Tp> _M_payload; }; template class _Optional_base<_Tp, false, true> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>> { friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>; public: // Constructors for disengaged optionals. constexpr _Optional_base() = default; // Constructors for engaged optionals. template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } // Copy and move constructors. constexpr _Optional_base(const _Optional_base& __other) : _M_payload(__other._M_payload._M_engaged, __other._M_payload) { } constexpr _Optional_base(_Optional_base&& __other) = default; // Assignment operators. _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_payload._M_engaged; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } constexpr const _Tp& _M_get() const noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } private: _Optional_payload<_Tp> _M_payload; }; template class _Optional_base<_Tp, true, false> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>> { friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>; public: // Constructors for disengaged optionals. constexpr _Optional_base() = default; // Constructors for engaged optionals. template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } // Copy and move constructors. constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible<_Tp>()) : _M_payload(__other._M_payload._M_engaged, std::move(__other._M_payload)) { } // Assignment operators. _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_payload._M_engaged; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } constexpr const _Tp& _M_get() const noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } private: _Optional_payload<_Tp> _M_payload; }; template class _Optional_base<_Tp, true, true> : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>> { friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>; public: // Constructors for disengaged optionals. constexpr _Optional_base() = default; // Constructors for engaged optionals. template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } // Copy and move constructors. constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) = default; // Assignment operators. _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; protected: constexpr bool _M_is_engaged() const noexcept { return this->_M_payload._M_engaged; } // The _M_get operations have _M_engaged as a precondition. constexpr _Tp& _M_get() noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } constexpr const _Tp& _M_get() const noexcept { __glibcxx_assert(this->_M_is_engaged()); return this->_M_payload._M_payload; } private: _Optional_payload<_Tp> _M_payload; }; template class optional; template using __converts_from_optional = __or_&>, is_constructible<_Tp, optional<_Up>&>, is_constructible<_Tp, const optional<_Up>&&>, is_constructible<_Tp, optional<_Up>&&>, is_convertible&, _Tp>, is_convertible&, _Tp>, is_convertible&&, _Tp>, is_convertible&&, _Tp>>; template using __assigns_from_optional = __or_&>, is_assignable<_Tp&, optional<_Up>&>, is_assignable<_Tp&, const optional<_Up>&&>, is_assignable<_Tp&, optional<_Up>&&>>; /** * @brief Class template for optional values. */ template class optional : private _Optional_base<_Tp>, private _Enable_copy_move< // Copy constructor. is_copy_constructible<_Tp>::value, // Copy assignment. __and_, is_copy_assignable<_Tp>>::value, // Move constructor. is_move_constructible<_Tp>::value, // Move assignment. __and_, is_move_assignable<_Tp>>::value, // Unique tag type. optional<_Tp>> { static_assert(!is_same_v, nullopt_t>); static_assert(!is_same_v, in_place_t>); static_assert(!is_reference_v<_Tp>); private: using _Base = _Optional_base<_Tp>; public: using value_type = _Tp; constexpr optional() = default; constexpr optional(nullopt_t) noexcept { } // Converting constructors for engaged optionals. template , decay_t<_Up>>>, __not_>>, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp> >::value, bool> = true> constexpr optional(_Up&& __t) : _Base(std::in_place, std::forward<_Up>(__t)) { } template , decay_t<_Up>>>, __not_>>, is_constructible<_Tp, _Up&&>, __not_> >::value, bool> = false> explicit constexpr optional(_Up&& __t) : _Base(std::in_place, std::forward<_Up>(__t)) { } template >, is_constructible<_Tp, const _Up&>, is_convertible, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(const optional<_Up>& __t) { if (__t) emplace(*__t); } template >, is_constructible<_Tp, const _Up&>, __not_>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(const optional<_Up>& __t) { if (__t) emplace(*__t); } template >, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(*__t)); } template >, is_constructible<_Tp, _Up&&>, __not_>, __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(*__t)); } template, bool> = false> explicit constexpr optional(in_place_t, _Args&&... __args) : _Base(std::in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> explicit constexpr optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { } // Assignment operators. optional& operator=(nullopt_t) noexcept { this->_M_reset(); return *this; } template enable_if_t<__and_< __not_, decay_t<_Up>>>, is_constructible<_Tp, _Up>, __not_<__and_, is_same<_Tp, decay_t<_Up>>>>, is_assignable<_Tp&, _Up>>::value, optional&> operator=(_Up&& __u) { if (this->_M_is_engaged()) this->_M_get() = std::forward<_Up>(__u); else this->_M_construct(std::forward<_Up>(__u)); return *this; } template enable_if_t<__and_< __not_>, is_constructible<_Tp, const _Up&>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>> >::value, optional&> operator=(const optional<_Up>& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = *__u; else this->_M_construct(*__u); } else { this->_M_reset(); } return *this; } template enable_if_t<__and_< __not_>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>> >::value, optional&> operator=(optional<_Up>&& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = std::move(*__u); else this->_M_construct(std::move(*__u)); } else { this->_M_reset(); } return *this; } template enable_if_t::value, _Tp&> emplace(_Args&&... __args) { this->_M_reset(); this->_M_construct(std::forward<_Args>(__args)...); return this->_M_get(); } template enable_if_t&, _Args&&...>::value, _Tp&> emplace(initializer_list<_Up> __il, _Args&&... __args) { this->_M_reset(); this->_M_construct(__il, std::forward<_Args>(__args)...); return this->_M_get(); } // Destructor is implicit, implemented in _Optional_base. // Swap. void swap(optional& __other) noexcept(is_nothrow_move_constructible<_Tp>() && is_nothrow_swappable_v<_Tp>) { using std::swap; if (this->_M_is_engaged() && __other._M_is_engaged()) swap(this->_M_get(), __other._M_get()); else if (this->_M_is_engaged()) { __other._M_construct(std::move(this->_M_get())); this->_M_destruct(); } else if (__other._M_is_engaged()) { this->_M_construct(std::move(__other._M_get())); __other._M_destruct(); } } // Observers. constexpr const _Tp* operator->() const { return std::__addressof(this->_M_get()); } constexpr _Tp* operator->() { return std::__addressof(this->_M_get()); } constexpr const _Tp& operator*() const& { return this->_M_get(); } constexpr _Tp& operator*()& { return this->_M_get(); } constexpr _Tp&& operator*()&& { return std::move(this->_M_get()); } constexpr const _Tp&& operator*() const&& { return std::move(this->_M_get()); } constexpr explicit operator bool() const noexcept { return this->_M_is_engaged(); } constexpr bool has_value() const noexcept { return this->_M_is_engaged(); } constexpr const _Tp& value() const& { return this->_M_is_engaged() ? this->_M_get() : (__throw_bad_optional_access(), this->_M_get()); } constexpr _Tp& value()& { return this->_M_is_engaged() ? this->_M_get() : (__throw_bad_optional_access(), this->_M_get()); } constexpr _Tp&& value()&& { return this->_M_is_engaged() ? std::move(this->_M_get()) : (__throw_bad_optional_access(), std::move(this->_M_get())); } constexpr const _Tp&& value() const&& { return this->_M_is_engaged() ? std::move(this->_M_get()) : (__throw_bad_optional_access(), std::move(this->_M_get())); } template constexpr _Tp value_or(_Up&& __u) const& { static_assert(is_copy_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); return this->_M_is_engaged() ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u)); } template constexpr _Tp value_or(_Up&& __u) && { static_assert(is_move_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); return this->_M_is_engaged() ? std::move(this->_M_get()) : static_cast<_Tp>(std::forward<_Up>(__u)); } void reset() noexcept { this->_M_reset(); } }; template using __optional_relop_t = enable_if_t::value, bool>; // Comparisons between optional values. template constexpr auto operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() == declval<_Up>())> { return static_cast(__lhs) == static_cast(__rhs) && (!__lhs || *__lhs == *__rhs); } template constexpr auto operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() != declval<_Up>())> { return static_cast(__lhs) != static_cast(__rhs) || (static_cast(__lhs) && *__lhs != *__rhs); } template constexpr auto operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() < declval<_Up>())> { return static_cast(__rhs) && (!__lhs || *__lhs < *__rhs); } template constexpr auto operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() > declval<_Up>())> { return static_cast(__lhs) && (!__rhs || *__lhs > *__rhs); } template constexpr auto operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() <= declval<_Up>())> { return !__lhs || (static_cast(__rhs) && *__lhs <= *__rhs); } template constexpr auto operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_relop_t() >= declval<_Up>())> { return !__rhs || (static_cast(__lhs) && *__lhs >= *__rhs); } // Comparisons with nullopt. template constexpr bool operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template constexpr bool operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } template constexpr bool operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast(__lhs); } template constexpr bool operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast(__rhs); } template constexpr bool operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept { return false; } template constexpr bool operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept { return static_cast(__rhs); } template constexpr bool operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept { return static_cast(__lhs); } template constexpr bool operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept { return false; } template constexpr bool operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template constexpr bool operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept { return true; } template constexpr bool operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept { return true; } template constexpr bool operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept { return !__rhs; } // Comparisons with value type. template constexpr auto operator==(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() == declval<_Up>())> { return __lhs && *__lhs == __rhs; } template constexpr auto operator==(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() == declval<_Tp>())> { return __rhs && __lhs == *__rhs; } template constexpr auto operator!=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() != declval<_Up>())> { return !__lhs || *__lhs != __rhs; } template constexpr auto operator!=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() != declval<_Tp>())> { return !__rhs || __lhs != *__rhs; } template constexpr auto operator<(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() < declval<_Up>())> { return !__lhs || *__lhs < __rhs; } template constexpr auto operator<(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() < declval<_Tp>())> { return __rhs && __lhs < *__rhs; } template constexpr auto operator>(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() > declval<_Up>())> { return __lhs && *__lhs > __rhs; } template constexpr auto operator>(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() > declval<_Tp>())> { return !__rhs || __lhs > *__rhs; } template constexpr auto operator<=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() <= declval<_Up>())> { return !__lhs || *__lhs <= __rhs; } template constexpr auto operator<=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() <= declval<_Tp>())> { return __rhs && __lhs <= *__rhs; } template constexpr auto operator>=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_relop_t() >= declval<_Up>())> { return __lhs && *__lhs >= __rhs; } template constexpr auto operator>=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_relop_t() >= declval<_Tp>())> { return !__rhs || __lhs >= *__rhs; } // Swap and creation functions. // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2748. swappable traits for optionals template inline enable_if_t && is_swappable_v<_Tp>> swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } template enable_if_t && is_swappable_v<_Tp>)> swap(optional<_Tp>&, optional<_Tp>&) = delete; template constexpr optional> make_optional(_Tp&& __t) { return optional> { std::forward<_Tp>(__t) }; } template constexpr optional<_Tp> make_optional(_Args&&... __args) { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; } template constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; } // Hash. template, bool = __poison_hash<_Up>::__enable_hash_call> struct __optional_hash_call_base { size_t operator()(const optional<_Tp>& __t) const noexcept(noexcept(hash<_Up>{}(*__t))) { // We pick an arbitrary hash for disengaged optionals which hopefully // usual values of _Tp won't typically hash to. constexpr size_t __magic_disengaged_hash = static_cast(-3333); return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash; } }; template struct __optional_hash_call_base<_Tp, _Up, false> {}; template struct hash> : private __poison_hash>, public __optional_hash_call_base<_Tp> { using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = optional<_Tp>; }; template struct __is_fast_hash>> : __is_fast_hash> { }; /// @} #if __cpp_deduction_guides >= 201606 template optional(_Tp) -> optional<_Tp>; #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++17 #endif // _GLIBCXX_OPTIONAL c++/8/array000064400000026611152640040170006331 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/array * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_ARRAY #define _GLIBCXX_ARRAY 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_CONTAINER template struct __array_traits { typedef _Tp _Type[_Nm]; typedef __is_swappable<_Tp> _Is_swappable; typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type& __t, std::size_t __n) noexcept { return const_cast<_Tp&>(__t[__n]); } static constexpr _Tp* _S_ptr(const _Type& __t) noexcept { return const_cast<_Tp*>(__t); } }; template struct __array_traits<_Tp, 0> { struct _Type { }; typedef true_type _Is_swappable; typedef true_type _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type&, std::size_t) noexcept { return *static_cast<_Tp*>(nullptr); } static constexpr _Tp* _S_ptr(const _Type&) noexcept { return nullptr; } }; /** * @brief A standard container for storing a fixed size sequence of elements. * * @ingroup sequences * * Meets the requirements of a container, a * reversible container, and a * sequence. * * Sets support random access iterators. * * @tparam Tp Type of element. Required to be a complete type. * @tparam N Number of elements. */ template struct array { typedef _Tp value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* iterator; typedef const value_type* const_iterator; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // Support for zero-sized arrays mandatory. typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type; typename _AT_Type::_Type _M_elems; // No explicit construct/copy/destroy for aggregate type. // DR 776. void fill(const value_type& __u) { std::fill_n(begin(), size(), __u); } void swap(array& __other) noexcept(_AT_Type::_Is_nothrow_swappable::value) { std::swap_ranges(begin(), end(), __other.begin()); } // Iterators. _GLIBCXX17_CONSTEXPR iterator begin() noexcept { return iterator(data()); } _GLIBCXX17_CONSTEXPR const_iterator begin() const noexcept { return const_iterator(data()); } _GLIBCXX17_CONSTEXPR iterator end() noexcept { return iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR const_iterator end() const noexcept { return const_iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR reverse_iterator rend() noexcept { return reverse_iterator(begin()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } _GLIBCXX17_CONSTEXPR const_iterator cbegin() const noexcept { return const_iterator(data()); } _GLIBCXX17_CONSTEXPR const_iterator cend() const noexcept { return const_iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } // Capacity. constexpr size_type size() const noexcept { return _Nm; } constexpr size_type max_size() const noexcept { return _Nm; } constexpr bool empty() const noexcept { return size() == 0; } // Element access. _GLIBCXX17_CONSTEXPR reference operator[](size_type __n) noexcept { return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference operator[](size_type __n) const noexcept { return _AT_Type::_S_ref(_M_elems, __n); } _GLIBCXX17_CONSTEXPR reference at(size_type __n) { if (__n >= _Nm) std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), __n, _Nm); return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference at(size_type __n) const { // Result of conditional expression must be an lvalue so use // boolean ? lvalue : (throw-expr, lvalue) return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), __n, _Nm), _AT_Type::_S_ref(_M_elems, 0)); } _GLIBCXX17_CONSTEXPR reference front() noexcept { return *begin(); } constexpr const_reference front() const noexcept { return _AT_Type::_S_ref(_M_elems, 0); } _GLIBCXX17_CONSTEXPR reference back() noexcept { return _Nm ? *(end() - 1) : *end(); } constexpr const_reference back() const noexcept { return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) : _AT_Type::_S_ref(_M_elems, 0); } _GLIBCXX17_CONSTEXPR pointer data() noexcept { return _AT_Type::_S_ptr(_M_elems); } _GLIBCXX17_CONSTEXPR const_pointer data() const noexcept { return _AT_Type::_S_ptr(_M_elems); } }; #if __cpp_deduction_guides >= 201606 template array(_Tp, _Up...) -> array && ...), _Tp>, 1 + sizeof...(_Up)>; #endif // Array comparisons. template inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } template inline bool operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one == __two); } template inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) { return std::lexicographical_compare(__a.begin(), __a.end(), __b.begin(), __b.end()); } template inline bool operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return __two < __one; } template inline bool operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one > __two); } template inline bool operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one < __two); } // Specialized algorithms. template inline #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 // Constrained free swap overload, see p0185r1 typename enable_if< _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_Is_swappable::value >::type #else void #endif swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two))) { __one.swap(__two); } #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 template typename enable_if< !_GLIBCXX_STD_C::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; #endif template constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } template constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::move(_GLIBCXX_STD_C::get<_Int>(__arr)); } template constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } template constexpr const _Tp&& get(const array<_Tp, _Nm>&& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::move(_GLIBCXX_STD_C::get<_Int>(__arr)); } _GLIBCXX_END_NAMESPACE_CONTAINER } // namespace std namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Tuple interface to class template array. /// tuple_size template struct tuple_size; /// Partial specialization for std::array template struct tuple_size<_GLIBCXX_STD_C::array<_Tp, _Nm>> : public integral_constant { }; /// tuple_element template struct tuple_element; /// Partial specialization for std::array template struct tuple_element<_Int, _GLIBCXX_STD_C::array<_Tp, _Nm>> { static_assert(_Int < _Nm, "index is out of bounds"); typedef _Tp type; }; template struct __is_tuple_like_impl<_GLIBCXX_STD_C::array<_Tp, _Nm>> : true_type { }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #ifdef _GLIBCXX_DEBUG # include #endif #ifdef _GLIBCXX_PROFILE # include #endif #endif // C++11 #endif // _GLIBCXX_ARRAY c++/8/cwchar000064400000014555152640040170006466 0ustar00// -*- C++ -*- forwarding header. // Copyright (C) 1997-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/cwchar * This is a Standard C++ Library file. You should @c \#include this file * in your programs, rather than any of the @a *.h implementation files. * * This is the C++ version of the Standard C Library header @c wchar.h, * and its contents are (mostly) the same as that header, but are all * contained in the namespace @c std (except for names which are defined * as macros in C). */ // // ISO C++ 14882: 21.4 // #pragma GCC system_header #include #if _GLIBCXX_HAVE_WCHAR_H #include #endif #ifndef _GLIBCXX_CWCHAR #define _GLIBCXX_CWCHAR 1 // Need to do a bit of trickery here with mbstate_t as char_traits // assumes it is in wchar.h, regardless of wchar_t specializations. #ifndef _GLIBCXX_HAVE_MBSTATE_T extern "C" { typedef struct { int __fill[6]; } mbstate_t; } #endif namespace std { using ::mbstate_t; } // namespace std // Get rid of those macros defined in in lieu of real functions. #undef btowc #undef fgetwc #undef fgetws #undef fputwc #undef fputws #undef fwide #undef fwprintf #undef fwscanf #undef getwc #undef getwchar #undef mbrlen #undef mbrtowc #undef mbsinit #undef mbsrtowcs #undef putwc #undef putwchar #undef swprintf #undef swscanf #undef ungetwc #undef vfwprintf #if _GLIBCXX_HAVE_VFWSCANF # undef vfwscanf #endif #undef vswprintf #if _GLIBCXX_HAVE_VSWSCANF # undef vswscanf #endif #undef vwprintf #if _GLIBCXX_HAVE_VWSCANF # undef vwscanf #endif #undef wcrtomb #undef wcscat #undef wcschr #undef wcscmp #undef wcscoll #undef wcscpy #undef wcscspn #undef wcsftime #undef wcslen #undef wcsncat #undef wcsncmp #undef wcsncpy #undef wcspbrk #undef wcsrchr #undef wcsrtombs #undef wcsspn #undef wcsstr #undef wcstod #if _GLIBCXX_HAVE_WCSTOF # undef wcstof #endif #undef wcstok #undef wcstol #undef wcstoul #undef wcsxfrm #undef wctob #undef wmemchr #undef wmemcmp #undef wmemcpy #undef wmemmove #undef wmemset #undef wprintf #undef wscanf #if _GLIBCXX_USE_WCHAR_T namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION using ::wint_t; using ::btowc; using ::fgetwc; using ::fgetws; using ::fputwc; using ::fputws; using ::fwide; using ::fwprintf; using ::fwscanf; using ::getwc; using ::getwchar; using ::mbrlen; using ::mbrtowc; using ::mbsinit; using ::mbsrtowcs; using ::putwc; using ::putwchar; #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF using ::swprintf; #endif using ::swscanf; using ::ungetwc; using ::vfwprintf; #if _GLIBCXX_HAVE_VFWSCANF using ::vfwscanf; #endif #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF using ::vswprintf; #endif #if _GLIBCXX_HAVE_VSWSCANF using ::vswscanf; #endif using ::vwprintf; #if _GLIBCXX_HAVE_VWSCANF using ::vwscanf; #endif using ::wcrtomb; using ::wcscat; using ::wcscmp; using ::wcscoll; using ::wcscpy; using ::wcscspn; using ::wcsftime; using ::wcslen; using ::wcsncat; using ::wcsncmp; using ::wcsncpy; using ::wcsrtombs; using ::wcsspn; using ::wcstod; #if _GLIBCXX_HAVE_WCSTOF using ::wcstof; #endif using ::wcstok; using ::wcstol; using ::wcstoul; using ::wcsxfrm; using ::wctob; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; using ::wmemset; using ::wprintf; using ::wscanf; using ::wcschr; using ::wcspbrk; using ::wcsrchr; using ::wcsstr; using ::wmemchr; #ifndef __CORRECT_ISO_CPP_WCHAR_H_PROTO inline wchar_t* wcschr(wchar_t* __p, wchar_t __c) { return wcschr(const_cast(__p), __c); } inline wchar_t* wcspbrk(wchar_t* __s1, const wchar_t* __s2) { return wcspbrk(const_cast(__s1), __s2); } inline wchar_t* wcsrchr(wchar_t* __p, wchar_t __c) { return wcsrchr(const_cast(__p), __c); } inline wchar_t* wcsstr(wchar_t* __s1, const wchar_t* __s2) { return wcsstr(const_cast(__s1), __s2); } inline wchar_t* wmemchr(wchar_t* __p, wchar_t __c, size_t __n) { return wmemchr(const_cast(__p), __c, __n); } #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace #if _GLIBCXX_USE_C99_WCHAR #undef wcstold #undef wcstoll #undef wcstoull namespace __gnu_cxx { #if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC extern "C" long double (wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw (); #endif #if !_GLIBCXX_USE_C99_DYNAMIC using ::wcstold; #endif #if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC extern "C" long long int (wcstoll)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw (); extern "C" unsigned long long int (wcstoull)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw (); #endif #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC using ::wcstoll; using ::wcstoull; #endif } // namespace __gnu_cxx namespace std { using ::__gnu_cxx::wcstold; using ::__gnu_cxx::wcstoll; using ::__gnu_cxx::wcstoull; } // namespace #endif #endif //_GLIBCXX_USE_WCHAR_T #if __cplusplus >= 201103L #ifdef _GLIBCXX_USE_WCHAR_T namespace std { #if _GLIBCXX_HAVE_WCSTOF using std::wcstof; #endif #if _GLIBCXX_HAVE_VFWSCANF using std::vfwscanf; #endif #if _GLIBCXX_HAVE_VSWSCANF using std::vswscanf; #endif #if _GLIBCXX_HAVE_VWSCANF using std::vwscanf; #endif #if _GLIBCXX_USE_C99_WCHAR using std::wcstold; using std::wcstoll; using std::wcstoull; #endif } // namespace #endif // _GLIBCXX_USE_WCHAR_T #endif // C++11 #endif c++/8/complex.h000064400000003074152640040170007106 0ustar00// -*- C++ -*- compatibility header. // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file complex.h * This is a Standard C++ Library header. */ #include #if __cplusplus >= 201103L # include #endif #if __cplusplus >= 201103L && defined(__STRICT_ANSI__) // For strict modes do not include the C library's , see PR 82417. #elif _GLIBCXX_HAVE_COMPLEX_H # include_next # ifdef _GLIBCXX_COMPLEX // See PR56111, keep the macro in C++03 if possible. # undef complex # endif #endif #ifndef _GLIBCXX_COMPLEX_H #define _GLIBCXX_COMPLEX_H 1 #endif c++/8/charconv000064400000040504152640040170007013 0ustar00// Primitive numeric conversions (to_chars and from_chars) -*- C++ -*- // Copyright (C) 2017-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/charconv * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_CHARCONV #define _GLIBCXX_CHARCONV 1 #pragma GCC system_header #if __cplusplus >= 201402L #include #include #include #include // for std::errc namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Result type of std::to_chars struct to_chars_result { char* ptr; errc ec; }; /// Result type of std::from_chars struct from_chars_result { const char* ptr; errc ec; }; namespace __detail { template using __is_one_of = __or_...>; template using __is_int_to_chars_type = __and_, __not_<__is_one_of<_Tp, bool, char16_t, char32_t #if _GLIBCXX_USE_WCHAR_T , wchar_t #endif >>>; template using __integer_to_chars_result_type = enable_if_t<__is_int_to_chars_type<_Tp>::value, to_chars_result>; template using __unsigned_least_t = conditional_t<(sizeof(_Tp) <= sizeof(int)), unsigned int, conditional_t<(sizeof(_Tp) <= sizeof(long)), unsigned long, conditional_t<(sizeof(_Tp) <= sizeof(long long)), unsigned long long, #if _GLIBCXX_USE_INT128 conditional_t<(sizeof(_Tp) <= sizeof(__int128)), unsigned __int128, #endif void #if _GLIBCXX_USE_INT128 > #endif >>>; // Generic implementation for arbitrary bases. template constexpr unsigned __to_chars_len(_Tp __value, int __base = 10) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); unsigned __n = 1; const int __b2 = __base * __base; const int __b3 = __b2 * __base; const int __b4 = __b3 * __base; for (;;) { if (__value < __base) return __n; if (__value < __b2) return __n + 1; if (__value < __b3) return __n + 2; if (__value < __b4) return __n + 3; __value /= (unsigned)__b4; __n += 4; } } template constexpr unsigned __to_chars_len_2(_Tp __value) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp); // N.B. __builtin_clzll is undefined if __value == 0, but std::to_chars // handles zero values directly. // For sizeof(_Tp) > 1 this is an order of magnitude faster than // the generic __to_chars_len. return __nbits - (__builtin_clzll(__value) - ((__CHAR_BIT__ * sizeof(long long)) - __nbits)); } template constexpr unsigned __to_chars_len_8(_Tp __value) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); constexpr size_t __nbits = __CHAR_BIT__ * sizeof(_Tp); if _GLIBCXX17_CONSTEXPR (__nbits <= 16) { return __value > 077777u ? 6u : __value > 07777u ? 5u : __value > 0777u ? 4u : __value > 077u ? 3u : __value > 07u ? 2u : 1u; } else return __to_chars_len(__value, 8); } // Generic implementation for arbitrary bases. template to_chars_result __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; const unsigned __len = __to_chars_len(__val, __base); if (__builtin_expect((__last - __first) < __len, 0)) { __res.ptr = __last; __res.ec = errc::value_too_large; return __res; } unsigned __pos = __len - 1; static constexpr char __digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; while (__val >= __base) { auto const __quo = __val / __base; auto const __rem = __val % __base; __first[__pos--] = __digits[__rem]; __val = __quo; } *__first = __digits[__val]; __res.ptr = __first + __len; __res.ec = {}; return __res; } template __integer_to_chars_result_type<_Tp> __to_chars_16(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; const unsigned __len = __to_chars_len(__val, 0x10); if (__builtin_expect((__last - __first) < __len, 0)) { __res.ptr = __last; __res.ec = errc::value_too_large; return __res; } static constexpr char __digits[513] = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f" "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f" "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f" "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f" "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f" "a0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf" "c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf" "e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"; unsigned __pos = __len - 1; while (__val >= 0x100) { auto const __num = (__val % 0x100) * 2; __val /= 0x100; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; __pos -= 2; } if (__val >= 0x10) { auto const __num = __val * 2; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; } else __first[__pos] = "0123456789abcdef"[__val]; __res.ptr = __first + __len; __res.ec = {}; return __res; } template __integer_to_chars_result_type<_Tp> __to_chars_10(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; const unsigned __len = __to_chars_len(__val, 10); if (__builtin_expect((__last - __first) < __len, 0)) { __res.ptr = __last; __res.ec = errc::value_too_large; return __res; } static constexpr char __digits[201] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; unsigned __pos = __len - 1; while (__val >= 100) { auto const __num = (__val % 100) * 2; __val /= 100; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; __pos -= 2; } if (__val >= 10) { auto const __num = __val * 2; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; } else __first[__pos] = '0' + __val; __res.ptr = __first + __len; __res.ec = {}; return __res; } template __integer_to_chars_result_type<_Tp> __to_chars_8(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; const unsigned __len = __to_chars_len_8(__val); if (__builtin_expect((__last - __first) < __len, 0)) { __res.ptr = __last; __res.ec = errc::value_too_large; return __res; } static constexpr char __digits[129] = "00010203040506071011121314151617" "20212223242526273031323334353637" "40414243444546475051525354555657" "60616263646566677071727374757677"; unsigned __pos = __len - 1; while (__val >= 0100) { auto const __num = (__val % 0100) * 2; __val /= 0100; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; __pos -= 2; } if (__val >= 010) { auto const __num = __val * 2; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; } else __first[__pos] = '0' + __val; __res.ptr = __first + __len; __res.ec = {}; return __res; } template __integer_to_chars_result_type<_Tp> __to_chars_2(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; const unsigned __len = __to_chars_len_2(__val); if (__builtin_expect((__last - __first) < __len, 0)) { __res.ptr = __last; __res.ec = errc::value_too_large; return __res; } unsigned __pos = __len - 1; while (__pos) { __first[__pos--] = '0' + (__val & 1); __val >>= 1; } *__first = '0' + (__val & 1); __res.ptr = __first + __len; __res.ec = {}; return __res; } } // namespace __detail template __detail::__integer_to_chars_result_type<_Tp> to_chars(char* __first, char* __last, _Tp __value, int __base = 10) { __glibcxx_assert(2 <= __base && __base <= 36); using _Up = __detail::__unsigned_least_t<_Tp>; _Up __unsigned_val = __value; if (__value == 0 && __first != __last) { *__first = '0'; return { __first + 1, errc{} }; } if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) if (__value < 0) { if (__builtin_expect(__first != __last, 1)) *__first++ = '-'; __unsigned_val = _Up(~__value) + _Up(1); } switch (__base) { case 16: return __detail::__to_chars_16(__first, __last, __unsigned_val); case 10: return __detail::__to_chars_10(__first, __last, __unsigned_val); case 8: return __detail::__to_chars_8(__first, __last, __unsigned_val); case 2: return __detail::__to_chars_2(__first, __last, __unsigned_val); default: return __detail::__to_chars(__first, __last, __unsigned_val, __base); } } namespace __detail { template bool __raise_and_add(_Tp& __val, int __base, unsigned char __c) { if (__builtin_mul_overflow(__val, __base, &__val) || __builtin_add_overflow(__val, __c, &__val)) return false; return true; } /// std::from_chars implementation for integers in base 2. template bool __from_chars_binary(const char*& __first, const char* __last, _Tp& __val) { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); const ptrdiff_t __len = __last - __first; int __i = 0; while (__i < __len) { const unsigned char __c = (unsigned)__first[__i] - '0'; if (__c < 2) __val = (__val << 1) | __c; else break; __i++; } __first += __i; return __i <= (sizeof(_Tp) * __CHAR_BIT__); } /// std::from_chars implementation for integers in bases 3 to 10. template bool __from_chars_digit(const char*& __first, const char* __last, _Tp& __val, int __base) { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); auto __matches = [__base](char __c) { return '0' <= __c && __c <= ('0' + (__base - 1)); }; while (__first != __last) { const char __c = *__first; if (__matches(__c)) { if (!__raise_and_add(__val, __base, __c - '0')) { while (++__first != __last && __matches(*__first)) ; return false; } __first++; } else return true; } return true; } constexpr unsigned char __from_chars_alpha_to_num(char __c) { switch (__c) { case 'a': case 'A': return 10; case 'b': case 'B': return 11; case 'c': case 'C': return 12; case 'd': case 'D': return 13; case 'e': case 'E': return 14; case 'f': case 'F': return 15; case 'g': case 'G': return 16; case 'h': case 'H': return 17; case 'i': case 'I': return 18; case 'j': case 'J': return 19; case 'k': case 'K': return 20; case 'l': case 'L': return 21; case 'm': case 'M': return 22; case 'n': case 'N': return 23; case 'o': case 'O': return 24; case 'p': case 'P': return 25; case 'q': case 'Q': return 26; case 'r': case 'R': return 27; case 's': case 'S': return 28; case 't': case 'T': return 29; case 'u': case 'U': return 30; case 'v': case 'V': return 31; case 'w': case 'W': return 32; case 'x': case 'X': return 33; case 'y': case 'Y': return 34; case 'z': case 'Z': return 35; } return std::numeric_limits::max(); } /// std::from_chars implementation for integers in bases 11 to 26. template bool __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, int __base) { bool __valid = true; while (__first != __last) { unsigned char __c = *__first; if (std::isdigit(__c)) __c -= '0'; else { __c = __from_chars_alpha_to_num(__c); if (__c >= __base) break; } if (__builtin_expect(__valid, 1)) __valid = __raise_and_add(__val, __base, __c); __first++; } return __valid; } template using __integer_from_chars_result_type = enable_if_t<__is_int_to_chars_type<_Tp>::value, from_chars_result>; } // namespace __detail /// std::from_chars for integral types. template __detail::__integer_from_chars_result_type<_Tp> from_chars(const char* __first, const char* __last, _Tp& __value, int __base = 10) { __glibcxx_assert(2 <= __base && __base <= 36); from_chars_result __res{__first, {}}; int __sign = 1; if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) if (__first != __last && *__first == '-') { __sign = -1; ++__first; } using _Up = __detail::__unsigned_least_t<_Tp>; _Up __val = 0; const auto __start = __first; bool __valid; if (__base == 2) __valid = __detail::__from_chars_binary(__first, __last, __val); else if (__base <= 10) __valid = __detail::__from_chars_digit(__first, __last, __val, __base); else __valid = __detail::__from_chars_alnum(__first, __last, __val, __base); if (__builtin_expect(__first == __start, 0)) __res.ec = errc::invalid_argument; else { __res.ptr = __first; if (!__valid) __res.ec = errc::result_out_of_range; else { if _GLIBCXX17_CONSTEXPR (std::is_signed<_Tp>::value) { _Tp __tmp; if (__builtin_mul_overflow(__val, __sign, &__tmp)) __res.ec = errc::result_out_of_range; else __value = __tmp; } else { if _GLIBCXX17_CONSTEXPR (numeric_limits<_Up>::max() > numeric_limits<_Tp>::max()) { if (__val > numeric_limits<_Tp>::max()) __res.ec = errc::result_out_of_range; else __value = __val; } else __value = __val; } } } return __res; } _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++14 #endif // _GLIBCXX_CHARCONV c++/8/tr1/cmath000064400000125436152640040170007022 0ustar00// TR1 cmath -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cmath * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CMATH #define _GLIBCXX_TR1_CMATH 1 #pragma GCC system_header #include #ifdef _GLIBCXX_USE_C99_MATH_TR1 #undef acosh #undef acoshf #undef acoshl #undef asinh #undef asinhf #undef asinhl #undef atanh #undef atanhf #undef atanhl #undef cbrt #undef cbrtf #undef cbrtl #undef copysign #undef copysignf #undef copysignl #undef erf #undef erff #undef erfl #undef erfc #undef erfcf #undef erfcl #undef exp2 #undef exp2f #undef exp2l #undef expm1 #undef expm1f #undef expm1l #undef fdim #undef fdimf #undef fdiml #undef fma #undef fmaf #undef fmal #undef fmax #undef fmaxf #undef fmaxl #undef fmin #undef fminf #undef fminl #undef hypot #undef hypotf #undef hypotl #undef ilogb #undef ilogbf #undef ilogbl #undef lgamma #undef lgammaf #undef lgammal #undef llrint #undef llrintf #undef llrintl #undef llround #undef llroundf #undef llroundl #undef log1p #undef log1pf #undef log1pl #undef log2 #undef log2f #undef log2l #undef logb #undef logbf #undef logbl #undef lrint #undef lrintf #undef lrintl #undef lround #undef lroundf #undef lroundl #undef nan #undef nanf #undef nanl #undef nearbyint #undef nearbyintf #undef nearbyintl #undef nextafter #undef nextafterf #undef nextafterl #undef nexttoward #undef nexttowardf #undef nexttowardl #undef remainder #undef remainderf #undef remainderl #undef remquo #undef remquof #undef remquol #undef rint #undef rintf #undef rintl #undef round #undef roundf #undef roundl #undef scalbln #undef scalblnf #undef scalblnl #undef scalbn #undef scalbnf #undef scalbnl #undef tgamma #undef tgammaf #undef tgammal #undef trunc #undef truncf #undef truncl #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { #if _GLIBCXX_USE_C99_MATH_TR1 // Using declarations to bring names from libc's into std::tr1. // types using ::double_t; using ::float_t; // functions using ::acosh; using ::acoshf; using ::acoshl; using ::asinh; using ::asinhf; using ::asinhl; using ::atanh; using ::atanhf; using ::atanhl; using ::cbrt; using ::cbrtf; using ::cbrtl; using ::copysign; using ::copysignf; using ::copysignl; using ::erf; using ::erff; using ::erfl; using ::erfc; using ::erfcf; using ::erfcl; using ::exp2; using ::exp2f; using ::exp2l; using ::expm1; using ::expm1f; using ::expm1l; using ::fdim; using ::fdimf; using ::fdiml; using ::fma; using ::fmaf; using ::fmal; using ::fmax; using ::fmaxf; using ::fmaxl; using ::fmin; using ::fminf; using ::fminl; using ::hypot; using ::hypotf; using ::hypotl; using ::ilogb; using ::ilogbf; using ::ilogbl; using ::lgamma; using ::lgammaf; using ::lgammal; using ::llrint; using ::llrintf; using ::llrintl; using ::llround; using ::llroundf; using ::llroundl; using ::log1p; using ::log1pf; using ::log1pl; using ::log2; using ::log2f; using ::log2l; using ::logb; using ::logbf; using ::logbl; using ::lrint; using ::lrintf; using ::lrintl; using ::lround; using ::lroundf; using ::lroundl; using ::nan; using ::nanf; using ::nanl; using ::nearbyint; using ::nearbyintf; using ::nearbyintl; using ::nextafter; using ::nextafterf; using ::nextafterl; using ::nexttoward; using ::nexttowardf; using ::nexttowardl; using ::remainder; using ::remainderf; using ::remainderl; using ::remquo; using ::remquof; using ::remquol; using ::rint; using ::rintf; using ::rintl; using ::round; using ::roundf; using ::roundl; using ::scalbln; using ::scalblnf; using ::scalblnl; using ::scalbn; using ::scalbnf; using ::scalbnl; using ::tgamma; using ::tgammaf; using ::tgammal; using ::trunc; using ::truncf; using ::truncl; #endif #if _GLIBCXX_USE_C99_MATH #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC /// Function template definitions [8.16.3]. template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type fpclassify(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isfinite(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isfinite(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isinf(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isinf(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isnan(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isnan(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isnormal(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isnormal(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type signbit(_Tp __f) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_signbit(__type(__f)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isgreater(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isgreater(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isgreaterequal(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isgreaterequal(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isless(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isless(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type islessequal(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_islessequal(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type islessgreater(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_islessgreater(__type(__f1), __type(__f2)); } template inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, int>::__type isunordered(_Tp __f1, _Tp __f2) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __builtin_isunordered(__type(__f1), __type(__f2)); } #endif #endif #if _GLIBCXX_USE_C99_MATH_TR1 /** Additional overloads [8.16.4]. * @{ */ // For functions defined in C++03 the additional overloads are already // declared in so we can just re-declare them in std::tr1. using std::acos; using std::asin; using std::atan; using std::atan2; using std::ceil; using std::cos; using std::cosh; using std::exp; using std::floor; using std::fmod; using std::frexp; using std::ldexp; using std::log; using std::log10; using std::sin; using std::sinh; using std::sqrt; using std::tan; using std::tanh; #if __cplusplus >= 201103L // Since C++11, defines additional overloads for these functions // in namespace std. using std::acosh; using std::asinh; using std::atanh; using std::cbrt; using std::copysign; using std::erf; using std::erfc; using std::exp2; using std::expm1; using std::fdim; using std::fma; using std::fmax; using std::fmin; using std::hypot; using std::ilogb; using std::lgamma; using std::llrint; using std::llround; using std::log1p; using std::log2; using std::logb; using std::lrint; using std::lround; using std::nan; using std::nearbyint; using std::nextafter; using std::nexttoward; using std::remainder; using std::remquo; using std::rint; using std::round; using std::scalbln; using std::scalbn; using std::tgamma; using std::trunc; #else // __cplusplus < 201103L // In C++03 we need to provide the additional overloads. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float acosh(float __x) { return __builtin_acoshf(__x); } inline long double acosh(long double __x) { return __builtin_acoshl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type acosh(_Tp __x) { return __builtin_acosh(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float asinh(float __x) { return __builtin_asinhf(__x); } inline long double asinh(long double __x) { return __builtin_asinhl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type asinh(_Tp __x) { return __builtin_asinh(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float atanh(float __x) { return __builtin_atanhf(__x); } inline long double atanh(long double __x) { return __builtin_atanhl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type atanh(_Tp __x) { return __builtin_atanh(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float cbrt(float __x) { return __builtin_cbrtf(__x); } inline long double cbrt(long double __x) { return __builtin_cbrtl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cbrt(_Tp __x) { return __builtin_cbrt(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float copysign(float __x, float __y) { return __builtin_copysignf(__x, __y); } inline long double copysign(long double __x, long double __y) { return __builtin_copysignl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type copysign(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return copysign(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float erf(float __x) { return __builtin_erff(__x); } inline long double erf(long double __x) { return __builtin_erfl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erf(_Tp __x) { return __builtin_erf(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float erfc(float __x) { return __builtin_erfcf(__x); } inline long double erfc(long double __x) { return __builtin_erfcl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erfc(_Tp __x) { return __builtin_erfc(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float exp2(float __x) { return __builtin_exp2f(__x); } inline long double exp2(long double __x) { return __builtin_exp2l(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type exp2(_Tp __x) { return __builtin_exp2(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float expm1(float __x) { return __builtin_expm1f(__x); } inline long double expm1(long double __x) { return __builtin_expm1l(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type expm1(_Tp __x) { return __builtin_expm1(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float fdim(float __x, float __y) { return __builtin_fdimf(__x, __y); } inline long double fdim(long double __x, long double __y) { return __builtin_fdiml(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fdim(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fdim(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float fma(float __x, float __y, float __z) { return __builtin_fmaf(__x, __y, __z); } inline long double fma(long double __x, long double __y, long double __z) { return __builtin_fmal(__x, __y, __z); } #endif template inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type fma(_Tp __x, _Up __y, _Vp __z) { typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; return fma(__type(__x), __type(__y), __type(__z)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float fmax(float __x, float __y) { return __builtin_fmaxf(__x, __y); } inline long double fmax(long double __x, long double __y) { return __builtin_fmaxl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmax(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmax(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float fmin(float __x, float __y) { return __builtin_fminf(__x, __y); } inline long double fmin(long double __x, long double __y) { return __builtin_fminl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmin(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmin(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float hypot(float __x, float __y) { return __builtin_hypotf(__x, __y); } inline long double hypot(long double __x, long double __y) { return __builtin_hypotl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type hypot(_Tp __y, _Up __x) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return hypot(__type(__y), __type(__x)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline int ilogb(float __x) { return __builtin_ilogbf(__x); } inline int ilogb(long double __x) { return __builtin_ilogbl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, int>::__type ilogb(_Tp __x) { return __builtin_ilogb(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float lgamma(float __x) { return __builtin_lgammaf(__x); } inline long double lgamma(long double __x) { return __builtin_lgammal(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type lgamma(_Tp __x) { return __builtin_lgamma(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline long long llrint(float __x) { return __builtin_llrintf(__x); } inline long long llrint(long double __x) { return __builtin_llrintl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llrint(_Tp __x) { return __builtin_llrint(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline long long llround(float __x) { return __builtin_llroundf(__x); } inline long long llround(long double __x) { return __builtin_llroundl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llround(_Tp __x) { return __builtin_llround(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float log1p(float __x) { return __builtin_log1pf(__x); } inline long double log1p(long double __x) { return __builtin_log1pl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log1p(_Tp __x) { return __builtin_log1p(__x); } // DR 568. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float log2(float __x) { return __builtin_log2f(__x); } inline long double log2(long double __x) { return __builtin_log2l(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log2(_Tp __x) { return __builtin_log2(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float logb(float __x) { return __builtin_logbf(__x); } inline long double logb(long double __x) { return __builtin_logbl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type logb(_Tp __x) { return __builtin_logb(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline long lrint(float __x) { return __builtin_lrintf(__x); } inline long lrint(long double __x) { return __builtin_lrintl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lrint(_Tp __x) { return __builtin_lrint(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline long lround(float __x) { return __builtin_lroundf(__x); } inline long lround(long double __x) { return __builtin_lroundl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lround(_Tp __x) { return __builtin_lround(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float nearbyint(float __x) { return __builtin_nearbyintf(__x); } inline long double nearbyint(long double __x) { return __builtin_nearbyintl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nearbyint(_Tp __x) { return __builtin_nearbyint(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float nextafter(float __x, float __y) { return __builtin_nextafterf(__x, __y); } inline long double nextafter(long double __x, long double __y) { return __builtin_nextafterl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type nextafter(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return nextafter(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float nexttoward(float __x, long double __y) { return __builtin_nexttowardf(__x, __y); } inline long double nexttoward(long double __x, long double __y) { return __builtin_nexttowardl(__x, __y); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nexttoward(_Tp __x, long double __y) { return __builtin_nexttoward(__x, __y); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float remainder(float __x, float __y) { return __builtin_remainderf(__x, __y); } inline long double remainder(long double __x, long double __y) { return __builtin_remainderl(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remainder(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remainder(__type(__x), __type(__y)); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float remquo(float __x, float __y, int* __pquo) { return __builtin_remquof(__x, __y, __pquo); } inline long double remquo(long double __x, long double __y, int* __pquo) { return __builtin_remquol(__x, __y, __pquo); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remquo(_Tp __x, _Up __y, int* __pquo) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remquo(__type(__x), __type(__y), __pquo); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float rint(float __x) { return __builtin_rintf(__x); } inline long double rint(long double __x) { return __builtin_rintl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type rint(_Tp __x) { return __builtin_rint(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float round(float __x) { return __builtin_roundf(__x); } inline long double round(long double __x) { return __builtin_roundl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type round(_Tp __x) { return __builtin_round(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float scalbln(float __x, long __ex) { return __builtin_scalblnf(__x, __ex); } inline long double scalbln(long double __x, long __ex) { return __builtin_scalblnl(__x, __ex); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbln(_Tp __x, long __ex) { return __builtin_scalbln(__x, __ex); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float scalbn(float __x, int __ex) { return __builtin_scalbnf(__x, __ex); } inline long double scalbn(long double __x, int __ex) { return __builtin_scalbnl(__x, __ex); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbn(_Tp __x, int __ex) { return __builtin_scalbn(__x, __ex); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float tgamma(float __x) { return __builtin_tgammaf(__x); } inline long double tgamma(long double __x) { return __builtin_tgammal(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tgamma(_Tp __x) { return __builtin_tgamma(__x); } #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float trunc(float __x) { return __builtin_truncf(__x); } inline long double trunc(long double __x) { return __builtin_truncl(__x); } #endif template inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type trunc(_Tp __x) { return __builtin_trunc(__x); } #endif // __cplusplus < 201103L // @} #endif /* _GLIBCXX_USE_C99_MATH_TR1 */ // DR 550. What should the return type of pow(float,int) be? // NB: C++11 and TR1 != C++03. // We cannot do "using std::pow;" because that would bring in unwanted // pow(*, int) overloads in C++03, with the wrong return type. Instead we // define all the necessary overloads, but the std::tr1::pow(double, double) // overload cannot be provided here, because would add it to // the global namespace where it would clash with ::pow(double,double) from // libc (revealed by the fix of PR c++/54537). // The solution is to forward std::tr1::pow(double,double) to // std::pow(double,double) via the function template below. See // the discussion about this issue here: // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float pow(float __x, float __y) { return std::pow(__x, __y); } inline long double pow(long double __x, long double __y) { return std::pow(__x, __y); } #endif template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(__type(__x), __type(__y)); } #if __cplusplus >= 201103L // We also deal with fabs in a special way, because "using std::fabs;" // could bring in C++11's std::fabs(const std::complex&) with a // different return type from std::tr1::fabs(const std::complex&). // We define the necessary overloads, except std::tr1::fabs(double) which // could clash with ::fabs(double) from libc. // The function template handles double as well as integers, forwarding // to std::fabs. #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP inline float fabs(float __x) { return __builtin_fabsf(__x); } inline long double fabs(long double __x) { return __builtin_fabsl(__x); } #endif #endif template inline typename __gnu_cxx::__promote<_Tp>::__type fabs(_Tp __x) { return std::fabs(__x); } #else // ! C++11 // For C++03 just use std::fabs as there is no overload for std::complex<>. using std::fabs; #endif // C++11 #if _GLIBCXX_USE_STD_SPEC_FUNCS /** * @defgroup tr1_math_spec_func Mathematical Special Functions * @ingroup numerics * * A collection of advanced mathematical special functions. * @{ */ using std::assoc_laguerref; using std::assoc_laguerrel; using std::assoc_laguerre; using std::assoc_legendref; using std::assoc_legendrel; using std::assoc_legendre; using std::betaf; using std::betal; using std::beta; using std::comp_ellint_1f; using std::comp_ellint_1l; using std::comp_ellint_1; using std::comp_ellint_2f; using std::comp_ellint_2l; using std::comp_ellint_2; using std::comp_ellint_3f; using std::comp_ellint_3l; using std::comp_ellint_3; using std::cyl_bessel_if; using std::cyl_bessel_il; using std::cyl_bessel_i; using std::cyl_bessel_jf; using std::cyl_bessel_jl; using std::cyl_bessel_j; using std::cyl_bessel_kf; using std::cyl_bessel_kl; using std::cyl_bessel_k; using std::cyl_neumannf; using std::cyl_neumannl; using std::cyl_neumann; using std::ellint_1f; using std::ellint_1l; using std::ellint_1; using std::ellint_2f; using std::ellint_2l; using std::ellint_2; using std::ellint_3f; using std::ellint_3l; using std::ellint_3; using std::expintf; using std::expintl; using std::expint; using std::hermitef; using std::hermitel; using std::hermite; using std::laguerref; using std::laguerrel; using std::laguerre; using std::legendref; using std::legendrel; using std::legendre; using std::riemann_zetaf; using std::riemann_zetal; using std::riemann_zeta; using std::sph_besself; using std::sph_bessell; using std::sph_bessel; using std::sph_legendref; using std::sph_legendrel; using std::sph_legendre; using std::sph_neumannf; using std::sph_neumannl; using std::sph_neumann; /* @} */ // tr1_math_spec_func #else // ! _GLIBCXX_USE_STD_SPEC_FUNCS } // namespace tr1 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #include #include #include #include #include #include #include #include #include #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @defgroup tr1_math_spec_func Mathematical Special Functions * @ingroup numerics * * A collection of advanced mathematical special functions. * @{ */ inline float assoc_laguerref(unsigned int __n, unsigned int __m, float __x) { return __detail::__assoc_laguerre(__n, __m, __x); } inline long double assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) { return __detail::__assoc_laguerre(__n, __m, __x); } /// 5.2.1.1 Associated Laguerre polynomials. template inline typename __gnu_cxx::__promote<_Tp>::__type assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__assoc_laguerre<__type>(__n, __m, __x); } inline float assoc_legendref(unsigned int __l, unsigned int __m, float __x) { return __detail::__assoc_legendre_p(__l, __m, __x); } inline long double assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) { return __detail::__assoc_legendre_p(__l, __m, __x); } /// 5.2.1.2 Associated Legendre functions. template inline typename __gnu_cxx::__promote<_Tp>::__type assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__assoc_legendre_p<__type>(__l, __m, __x); } inline float betaf(float __x, float __y) { return __detail::__beta(__x, __y); } inline long double betal(long double __x, long double __y) { return __detail::__beta(__x, __y); } /// 5.2.1.3 Beta functions. template inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type beta(_Tpx __x, _Tpy __y) { typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type; return __detail::__beta<__type>(__x, __y); } inline float comp_ellint_1f(float __k) { return __detail::__comp_ellint_1(__k); } inline long double comp_ellint_1l(long double __k) { return __detail::__comp_ellint_1(__k); } /// 5.2.1.4 Complete elliptic integrals of the first kind. template inline typename __gnu_cxx::__promote<_Tp>::__type comp_ellint_1(_Tp __k) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__comp_ellint_1<__type>(__k); } inline float comp_ellint_2f(float __k) { return __detail::__comp_ellint_2(__k); } inline long double comp_ellint_2l(long double __k) { return __detail::__comp_ellint_2(__k); } /// 5.2.1.5 Complete elliptic integrals of the second kind. template inline typename __gnu_cxx::__promote<_Tp>::__type comp_ellint_2(_Tp __k) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__comp_ellint_2<__type>(__k); } inline float comp_ellint_3f(float __k, float __nu) { return __detail::__comp_ellint_3(__k, __nu); } inline long double comp_ellint_3l(long double __k, long double __nu) { return __detail::__comp_ellint_3(__k, __nu); } /// 5.2.1.6 Complete elliptic integrals of the third kind. template inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type comp_ellint_3(_Tp __k, _Tpn __nu) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; return __detail::__comp_ellint_3<__type>(__k, __nu); } inline float cyl_bessel_if(float __nu, float __x) { return __detail::__cyl_bessel_i(__nu, __x); } inline long double cyl_bessel_il(long double __nu, long double __x) { return __detail::__cyl_bessel_i(__nu, __x); } /// 5.2.1.8 Regular modified cylindrical Bessel functions. template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_i(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_i<__type>(__nu, __x); } inline float cyl_bessel_jf(float __nu, float __x) { return __detail::__cyl_bessel_j(__nu, __x); } inline long double cyl_bessel_jl(long double __nu, long double __x) { return __detail::__cyl_bessel_j(__nu, __x); } /// 5.2.1.9 Cylindrical Bessel functions (of the first kind). template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_j(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_j<__type>(__nu, __x); } inline float cyl_bessel_kf(float __nu, float __x) { return __detail::__cyl_bessel_k(__nu, __x); } inline long double cyl_bessel_kl(long double __nu, long double __x) { return __detail::__cyl_bessel_k(__nu, __x); } /// 5.2.1.10 Irregular modified cylindrical Bessel functions. template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_k(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_k<__type>(__nu, __x); } inline float cyl_neumannf(float __nu, float __x) { return __detail::__cyl_neumann_n(__nu, __x); } inline long double cyl_neumannl(long double __nu, long double __x) { return __detail::__cyl_neumann_n(__nu, __x); } /// 5.2.1.11 Cylindrical Neumann functions. template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_neumann(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_neumann_n<__type>(__nu, __x); } inline float ellint_1f(float __k, float __phi) { return __detail::__ellint_1(__k, __phi); } inline long double ellint_1l(long double __k, long double __phi) { return __detail::__ellint_1(__k, __phi); } /// 5.2.1.12 Incomplete elliptic integrals of the first kind. template inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type ellint_1(_Tp __k, _Tpp __phi) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; return __detail::__ellint_1<__type>(__k, __phi); } inline float ellint_2f(float __k, float __phi) { return __detail::__ellint_2(__k, __phi); } inline long double ellint_2l(long double __k, long double __phi) { return __detail::__ellint_2(__k, __phi); } /// 5.2.1.13 Incomplete elliptic integrals of the second kind. template inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type ellint_2(_Tp __k, _Tpp __phi) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; return __detail::__ellint_2<__type>(__k, __phi); } inline float ellint_3f(float __k, float __nu, float __phi) { return __detail::__ellint_3(__k, __nu, __phi); } inline long double ellint_3l(long double __k, long double __nu, long double __phi) { return __detail::__ellint_3(__k, __nu, __phi); } /// 5.2.1.14 Incomplete elliptic integrals of the third kind. template inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) { typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; return __detail::__ellint_3<__type>(__k, __nu, __phi); } inline float expintf(float __x) { return __detail::__expint(__x); } inline long double expintl(long double __x) { return __detail::__expint(__x); } /// 5.2.1.15 Exponential integrals. template inline typename __gnu_cxx::__promote<_Tp>::__type expint(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__expint<__type>(__x); } inline float hermitef(unsigned int __n, float __x) { return __detail::__poly_hermite(__n, __x); } inline long double hermitel(unsigned int __n, long double __x) { return __detail::__poly_hermite(__n, __x); } /// 5.2.1.16 Hermite polynomials. template inline typename __gnu_cxx::__promote<_Tp>::__type hermite(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__poly_hermite<__type>(__n, __x); } inline float laguerref(unsigned int __n, float __x) { return __detail::__laguerre(__n, __x); } inline long double laguerrel(unsigned int __n, long double __x) { return __detail::__laguerre(__n, __x); } /// 5.2.1.18 Laguerre polynomials. template inline typename __gnu_cxx::__promote<_Tp>::__type laguerre(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__laguerre<__type>(__n, __x); } inline float legendref(unsigned int __n, float __x) { return __detail::__poly_legendre_p(__n, __x); } inline long double legendrel(unsigned int __n, long double __x) { return __detail::__poly_legendre_p(__n, __x); } /// 5.2.1.19 Legendre polynomials. template inline typename __gnu_cxx::__promote<_Tp>::__type legendre(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__poly_legendre_p<__type>(__n, __x); } inline float riemann_zetaf(float __x) { return __detail::__riemann_zeta(__x); } inline long double riemann_zetal(long double __x) { return __detail::__riemann_zeta(__x); } /// 5.2.1.20 Riemann zeta function. template inline typename __gnu_cxx::__promote<_Tp>::__type riemann_zeta(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__riemann_zeta<__type>(__x); } inline float sph_besself(unsigned int __n, float __x) { return __detail::__sph_bessel(__n, __x); } inline long double sph_bessell(unsigned int __n, long double __x) { return __detail::__sph_bessel(__n, __x); } /// 5.2.1.21 Spherical Bessel functions. template inline typename __gnu_cxx::__promote<_Tp>::__type sph_bessel(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_bessel<__type>(__n, __x); } inline float sph_legendref(unsigned int __l, unsigned int __m, float __theta) { return __detail::__sph_legendre(__l, __m, __theta); } inline long double sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) { return __detail::__sph_legendre(__l, __m, __theta); } /// 5.2.1.22 Spherical associated Legendre functions. template inline typename __gnu_cxx::__promote<_Tp>::__type sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_legendre<__type>(__l, __m, __theta); } inline float sph_neumannf(unsigned int __n, float __x) { return __detail::__sph_neumann(__n, __x); } inline long double sph_neumannl(unsigned int __n, long double __x) { return __detail::__sph_neumann(__n, __x); } /// 5.2.1.23 Spherical Neumann functions. template inline typename __gnu_cxx::__promote<_Tp>::__type sph_neumann(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_neumann<__type>(__n, __x); } /* @} */ // tr1_math_spec_func #endif // _GLIBCXX_USE_STD_SPEC_FUNCS } // namespace tr1 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #if _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__) namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { using __gnu_cxx::conf_hypergf; using __gnu_cxx::conf_hypergl; using __gnu_cxx::conf_hyperg; using __gnu_cxx::hypergf; using __gnu_cxx::hypergl; using __gnu_cxx::hyperg; } // namespace tr1 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #else // ! (_GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__)) #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { inline float conf_hypergf(float __a, float __c, float __x) { return __detail::__conf_hyperg(__a, __c, __x); } inline long double conf_hypergl(long double __a, long double __c, long double __x) { return __detail::__conf_hyperg(__a, __c, __x); } /// 5.2.1.7 Confluent hypergeometric functions. template inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x) { typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type; return __detail::__conf_hyperg<__type>(__a, __c, __x); } inline float hypergf(float __a, float __b, float __c, float __x) { return __detail::__hyperg(__a, __b, __c, __x); } inline long double hypergl(long double __a, long double __b, long double __c, long double __x) { return __detail::__hyperg(__a, __b, __c, __x); } /// 5.2.1.17 Hypergeometric functions. template inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x) { typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type; return __detail::__hyperg<__type>(__a, __b, __c, __x); } } // namespace tr1 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // _GLIBCXX_USE_STD_SPEC_FUNCS && !defined(__STRICT_ANSI__) #endif // _GLIBCXX_TR1_CMATH c++/8/tr1/utility000064400000006231152640040170007420 0ustar00// TR1 utility -*- C++ -*- // Copyright (C) 2004-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/utility * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_UTILITY #define _GLIBCXX_TR1_UTILITY 1 #pragma GCC system_header #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { template class tuple_size; template class tuple_element; // Various functions which give std::pair a tuple-like interface. template struct tuple_size > { static const int value = 2; }; template const int tuple_size >::value; template struct tuple_element<0, std::pair<_Tp1, _Tp2> > { typedef _Tp1 type; }; template struct tuple_element<1, std::pair<_Tp1, _Tp2> > { typedef _Tp2 type; }; template struct __pair_get; template<> struct __pair_get<0> { template static _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair) { return __pair.first; } template static const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair) { return __pair.first; } }; template<> struct __pair_get<1> { template static _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair) { return __pair.second; } template static const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair) { return __pair.second; } }; template inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type& get(std::pair<_Tp1, _Tp2>& __in) { return __pair_get<_Int>::__get(__in); } template inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type& get(const std::pair<_Tp1, _Tp2>& __in) { return __pair_get<_Int>::__const_get(__in); } } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_UTILITY c++/8/tr1/math.h000064400000010711152640040170007072 0ustar00// TR1 math.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/math.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_MATH_H #define _GLIBCXX_TR1_MATH_H 1 #include #if _GLIBCXX_USE_C99_MATH_TR1 using std::tr1::acos; using std::tr1::acosh; using std::tr1::asin; using std::tr1::asinh; using std::tr1::atan; using std::tr1::atan2; using std::tr1::atanh; using std::tr1::cbrt; using std::tr1::ceil; using std::tr1::copysign; using std::tr1::cos; using std::tr1::cosh; using std::tr1::erf; using std::tr1::erfc; using std::tr1::exp; using std::tr1::exp2; using std::tr1::expm1; using std::tr1::fabs; using std::tr1::fdim; using std::tr1::floor; using std::tr1::fma; using std::tr1::fmax; using std::tr1::fmin; using std::tr1::fmod; using std::tr1::frexp; using std::tr1::hypot; using std::tr1::ilogb; using std::tr1::ldexp; using std::tr1::lgamma; using std::tr1::llrint; using std::tr1::llround; using std::tr1::log; using std::tr1::log10; using std::tr1::log1p; using std::tr1::log2; using std::tr1::logb; using std::tr1::lrint; using std::tr1::lround; using std::tr1::nearbyint; using std::tr1::nextafter; using std::tr1::nexttoward; using std::tr1::pow; using std::tr1::remainder; using std::tr1::remquo; using std::tr1::rint; using std::tr1::round; using std::tr1::scalbln; using std::tr1::scalbn; using std::tr1::sin; using std::tr1::sinh; using std::tr1::sqrt; using std::tr1::tan; using std::tr1::tanh; using std::tr1::tgamma; using std::tr1::trunc; #endif using std::tr1::assoc_laguerref; using std::tr1::assoc_laguerre; using std::tr1::assoc_laguerrel; using std::tr1::assoc_legendref; using std::tr1::assoc_legendre; using std::tr1::assoc_legendrel; using std::tr1::betaf; using std::tr1::beta; using std::tr1::betal; using std::tr1::comp_ellint_1f; using std::tr1::comp_ellint_1; using std::tr1::comp_ellint_1l; using std::tr1::comp_ellint_2f; using std::tr1::comp_ellint_2; using std::tr1::comp_ellint_2l; using std::tr1::comp_ellint_3f; using std::tr1::comp_ellint_3; using std::tr1::comp_ellint_3l; using std::tr1::conf_hypergf; using std::tr1::conf_hyperg; using std::tr1::conf_hypergl; using std::tr1::cyl_bessel_if; using std::tr1::cyl_bessel_i; using std::tr1::cyl_bessel_il; using std::tr1::cyl_bessel_jf; using std::tr1::cyl_bessel_j; using std::tr1::cyl_bessel_jl; using std::tr1::cyl_bessel_kf; using std::tr1::cyl_bessel_k; using std::tr1::cyl_bessel_kl; using std::tr1::cyl_neumannf; using std::tr1::cyl_neumann; using std::tr1::cyl_neumannl; using std::tr1::ellint_1f; using std::tr1::ellint_1; using std::tr1::ellint_1l; using std::tr1::ellint_2f; using std::tr1::ellint_2; using std::tr1::ellint_2l; using std::tr1::ellint_3f; using std::tr1::ellint_3; using std::tr1::ellint_3l; using std::tr1::expintf; using std::tr1::expint; using std::tr1::expintl; using std::tr1::hermitef; using std::tr1::hermite; using std::tr1::hermitel; using std::tr1::hypergf; using std::tr1::hyperg; using std::tr1::hypergl; using std::tr1::laguerref; using std::tr1::laguerre; using std::tr1::laguerrel; using std::tr1::legendref; using std::tr1::legendre; using std::tr1::legendrel; using std::tr1::riemann_zetaf; using std::tr1::riemann_zeta; using std::tr1::riemann_zetal; using std::tr1::sph_besself; using std::tr1::sph_bessel; using std::tr1::sph_bessell; using std::tr1::sph_legendref; using std::tr1::sph_legendre; using std::tr1::sph_legendrel; using std::tr1::sph_neumannf; using std::tr1::sph_neumann; using std::tr1::sph_neumannl; #endif // _GLIBCXX_TR1_MATH_H c++/8/tr1/array000064400000015464152640040170007043 0ustar00// class template array -*- C++ -*- // Copyright (C) 2004-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/array * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_ARRAY #define _GLIBCXX_TR1_ARRAY 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @brief A standard container for storing a fixed size sequence of elements. * * @ingroup sequences * * Meets the requirements of a container, a * reversible container, and a * sequence. * * Sets support random access iterators. * * @param Tp Type of element. Required to be a complete type. * @param N Number of elements. */ template struct array { typedef _Tp value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* iterator; typedef const value_type* const_iterator; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // Support for zero-sized arrays mandatory. value_type _M_instance[_Nm ? _Nm : 1]; // No explicit construct/copy/destroy for aggregate type. void assign(const value_type& __u) { std::fill_n(begin(), size(), __u); } void swap(array& __other) { std::swap_ranges(begin(), end(), __other.begin()); } // Iterators. iterator begin() { return iterator(std::__addressof(_M_instance[0])); } const_iterator begin() const { return const_iterator(std::__addressof(_M_instance[0])); } iterator end() { return iterator(std::__addressof(_M_instance[_Nm])); } const_iterator end() const { return const_iterator(std::__addressof(_M_instance[_Nm])); } reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } // Capacity. size_type size() const { return _Nm; } size_type max_size() const { return _Nm; } bool empty() const { return size() == 0; } // Element access. reference operator[](size_type __n) { return _M_instance[__n]; } const_reference operator[](size_type __n) const { return _M_instance[__n]; } reference at(size_type __n) { if (__n >= _Nm) std::__throw_out_of_range(__N("array::at")); return _M_instance[__n]; } const_reference at(size_type __n) const { if (__n >= _Nm) std::__throw_out_of_range(__N("array::at")); return _M_instance[__n]; } reference front() { return *begin(); } const_reference front() const { return *begin(); } reference back() { return _Nm ? *(end() - 1) : *end(); } const_reference back() const { return _Nm ? *(end() - 1) : *end(); } _Tp* data() { return std::__addressof(_M_instance[0]); } const _Tp* data() const { return std::__addressof(_M_instance[0]); } }; // Array comparisons. template inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } template inline bool operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one == __two); } template inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) { return std::lexicographical_compare(__a.begin(), __a.end(), __b.begin(), __b.end()); } template inline bool operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return __two < __one; } template inline bool operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one > __two); } template inline bool operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one < __two); } // Specialized algorithms [6.2.2.2]. template inline void swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) { __one.swap(__two); } // Tuple interface to class template array [6.2.2.5]. /// tuple_size template class tuple_size; /// tuple_element template class tuple_element; template struct tuple_size > { static const int value = _Nm; }; template const int tuple_size >::value; template struct tuple_element<_Int, array<_Tp, _Nm> > { typedef _Tp type; }; template inline _Tp& get(array<_Tp, _Nm>& __arr) { return __arr[_Int]; } template inline const _Tp& get(const array<_Tp, _Nm>& __arr) { return __arr[_Int]; } } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_ARRAY c++/8/tr1/cwchar000064400000003266152640040170007171 0ustar00// TR1 cwchar -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cwchar * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CWCHAR #define _GLIBCXX_TR1_CWCHAR 1 #pragma GCC system_header #include #ifdef _GLIBCXX_USE_WCHAR_T namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { #if _GLIBCXX_HAVE_WCSTOF using std::wcstof; #endif #if _GLIBCXX_HAVE_VFWSCANF using std::vfwscanf; #endif #if _GLIBCXX_HAVE_VSWSCANF using std::vswscanf; #endif #if _GLIBCXX_HAVE_VWSCANF using std::vwscanf; #endif #if _GLIBCXX_USE_C99_WCHAR using std::wcstold; using std::wcstoll; using std::wcstoull; #endif } } #endif // _GLIBCXX_USE_WCHAR_T #endif // _GLIBCXX_TR1_CWCHAR c++/8/tr1/complex.h000064400000002355152640040170007615 0ustar00// TR1 complex.h -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/complex.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_COMPLEX_H #define _GLIBCXX_TR1_COMPLEX_H 1 #include #endif // _GLIBCXX_TR1_COMPLEX_H c++/8/tr1/hypergeometric.tcc000064400000066642152640040170011527 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/hypergeometric.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based: // (1) Handbook of Mathematical Functions, // ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 6, pp. 555-566 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl #ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC #define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief This routine returns the confluent hypergeometric function * by series expansion. * * @f[ * _1F_1(a;c;x) = \frac{\Gamma(c)}{\Gamma(a)} * \sum_{n=0}^{\infty} * \frac{\Gamma(a+n)}{\Gamma(c+n)} * \frac{x^n}{n!} * @f] * * If a and b are integers and a < 0 and either b > 0 or b < a * then the series is a polynomial with a finite number of * terms. If b is an integer and b <= 0 the confluent * hypergeometric function is undefined. * * @param __a The "numerator" parameter. * @param __c The "denominator" parameter. * @param __x The argument of the confluent hypergeometric function. * @return The confluent hypergeometric function. */ template _Tp __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __Fac = _Tp(1); const unsigned int __max_iter = 100000; unsigned int __i; for (__i = 0; __i < __max_iter; ++__i) { __term *= (__a + _Tp(__i)) * __x / ((__c + _Tp(__i)) * _Tp(1 + __i)); if (std::abs(__term) < __eps) { break; } __Fac += __term; } if (__i == __max_iter) std::__throw_runtime_error(__N("Series failed to converge " "in __conf_hyperg_series.")); return __Fac; } /** * @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$ * by an iterative procedure described in * Luke, Algorithms for the Computation of Mathematical Functions. * * Like the case of the 2F1 rational approximations, these are * probably guaranteed to converge for x < 0, barring gross * numerical instability in the pre-asymptotic regime. */ template _Tp __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) { const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); const int __nmax = 20000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __x = -__xin; const _Tp __x3 = __x * __x * __x; const _Tp __t0 = __a / __c; const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); _Tp __F = _Tp(1); _Tp __prec; _Tp __Bnm3 = _Tp(1); _Tp __Bnm2 = _Tp(1) + __t1 * __x; _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); _Tp __Anm3 = _Tp(1); _Tp __Anm2 = __Bnm2 - __t0 * __x; _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; int __n = 3; while(1) { _Tp __npam1 = _Tp(__n - 1) + __a; _Tp __npcm1 = _Tp(__n - 1) + __c; _Tp __npam2 = _Tp(__n - 2) + __a; _Tp __npcm2 = _Tp(__n - 2) + __c; _Tp __tnm1 = _Tp(2 * __n - 1); _Tp __tnm3 = _Tp(2 * __n - 3); _Tp __tnm5 = _Tp(2 * __n - 5); _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); _Tp __F2 = (_Tp(__n) + __a) * __npam1 / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; _Tp __r = __An / __Bn; __prec = std::abs((__F - __r) / __F); __F = __r; if (__prec < __eps || __n > __nmax) break; if (std::abs(__An) > __big || std::abs(__Bn) > __big) { __An /= __big; __Bn /= __big; __Anm1 /= __big; __Bnm1 /= __big; __Anm2 /= __big; __Bnm2 /= __big; __Anm3 /= __big; __Bnm3 /= __big; } else if (std::abs(__An) < _Tp(1) / __big || std::abs(__Bn) < _Tp(1) / __big) { __An *= __big; __Bn *= __big; __Anm1 *= __big; __Bnm1 *= __big; __Anm2 *= __big; __Bnm2 *= __big; __Anm3 *= __big; __Bnm3 *= __big; } ++__n; __Bnm3 = __Bnm2; __Bnm2 = __Bnm1; __Bnm1 = __Bn; __Anm3 = __Anm2; __Anm2 = __Anm1; __Anm1 = __An; } if (__n >= __nmax) std::__throw_runtime_error(__N("Iteration failed to converge " "in __conf_hyperg_luke.")); return __F; } /** * @brief Return the confluent hypogeometric function * @f$ _1F_1(a;c;x) @f$. * * @todo Handle b == nonpositive integer blowup - return NaN. * * @param __a The @a numerator parameter. * @param __c The @a denominator parameter. * @param __x The argument of the confluent hypergeometric function. * @return The confluent hypergeometric function. */ template _Tp __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) { #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __c_nint = _GLIBCXX_MATH_NS::nearbyint(__c); #else const _Tp __c_nint = static_cast(__c + _Tp(0.5L)); #endif if (__isnan(__a) || __isnan(__c) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__c_nint == __c && __c_nint <= 0) return std::numeric_limits<_Tp>::infinity(); else if (__a == _Tp(0)) return _Tp(1); else if (__c == __a) return std::exp(__x); else if (__x < _Tp(0)) return __conf_hyperg_luke(__a, __c, __x); else return __conf_hyperg_series(__a, __c, __x); } /** * @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$ * by series expansion. * * The hypogeometric function is defined by * @f[ * _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)} * \sum_{n=0}^{\infty} * \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)} * \frac{x^n}{n!} * @f] * * This works and it's pretty fast. * * @param __a The first @a numerator parameter. * @param __a The second @a numerator parameter. * @param __c The @a denominator parameter. * @param __x The argument of the confluent hypergeometric function. * @return The confluent hypergeometric function. */ template _Tp __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __Fabc = _Tp(1); const unsigned int __max_iter = 100000; unsigned int __i; for (__i = 0; __i < __max_iter; ++__i) { __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x / ((__c + _Tp(__i)) * _Tp(1 + __i)); if (std::abs(__term) < __eps) { break; } __Fabc += __term; } if (__i == __max_iter) std::__throw_runtime_error(__N("Series failed to converge " "in __hyperg_series.")); return __Fabc; } /** * @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$ * by an iterative procedure described in * Luke, Algorithms for the Computation of Mathematical Functions. */ template _Tp __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) { const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); const int __nmax = 20000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __x = -__xin; const _Tp __x3 = __x * __x * __x; const _Tp __t0 = __a * __b / __c; const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); _Tp __F = _Tp(1); _Tp __Bnm3 = _Tp(1); _Tp __Bnm2 = _Tp(1) + __t1 * __x; _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); _Tp __Anm3 = _Tp(1); _Tp __Anm2 = __Bnm2 - __t0 * __x; _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; int __n = 3; while (1) { const _Tp __npam1 = _Tp(__n - 1) + __a; const _Tp __npbm1 = _Tp(__n - 1) + __b; const _Tp __npcm1 = _Tp(__n - 1) + __c; const _Tp __npam2 = _Tp(__n - 2) + __a; const _Tp __npbm2 = _Tp(__n - 2) + __b; const _Tp __npcm2 = _Tp(__n - 2) + __c; const _Tp __tnm1 = _Tp(2 * __n - 1); const _Tp __tnm3 = _Tp(2 * __n - 3); const _Tp __tnm5 = _Tp(2 * __n - 5); const _Tp __n2 = __n * __n; const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) / (_Tp(2) * __tnm3 * __npcm1); const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + _Tp(2) - __a * __b) * __npam1 * __npbm1 / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; const _Tp __r = __An / __Bn; const _Tp __prec = std::abs((__F - __r) / __F); __F = __r; if (__prec < __eps || __n > __nmax) break; if (std::abs(__An) > __big || std::abs(__Bn) > __big) { __An /= __big; __Bn /= __big; __Anm1 /= __big; __Bnm1 /= __big; __Anm2 /= __big; __Bnm2 /= __big; __Anm3 /= __big; __Bnm3 /= __big; } else if (std::abs(__An) < _Tp(1) / __big || std::abs(__Bn) < _Tp(1) / __big) { __An *= __big; __Bn *= __big; __Anm1 *= __big; __Bnm1 *= __big; __Anm2 *= __big; __Bnm2 *= __big; __Anm3 *= __big; __Bnm3 *= __big; } ++__n; __Bnm3 = __Bnm2; __Bnm2 = __Bnm1; __Bnm1 = __Bn; __Anm3 = __Anm2; __Anm2 = __Anm1; __Anm1 = __An; } if (__n >= __nmax) std::__throw_runtime_error(__N("Iteration failed to converge " "in __hyperg_luke.")); return __F; } /** * @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$ * by the reflection formulae in Abramowitz & Stegun formula * 15.3.6 for d = c - a - b not integral and formula 15.3.11 for * d = c - a - b integral. This assumes a, b, c != negative * integer. * * The hypogeometric function is defined by * @f[ * _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)} * \sum_{n=0}^{\infty} * \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)} * \frac{x^n}{n!} * @f] * * The reflection formula for nonintegral @f$ d = c - a - b @f$ is: * @f[ * _2F_1(a,b;c;x) = \frac{\Gamma(c)\Gamma(d)}{\Gamma(c-a)\Gamma(c-b)} * _2F_1(a,b;1-d;1-x) * + \frac{\Gamma(c)\Gamma(-d)}{\Gamma(a)\Gamma(b)} * _2F_1(c-a,c-b;1+d;1-x) * @f] * * The reflection formula for integral @f$ m = c - a - b @f$ is: * @f[ * _2F_1(a,b;a+b+m;x) = \frac{\Gamma(m)\Gamma(a+b+m)}{\Gamma(a+m)\Gamma(b+m)} * \sum_{k=0}^{m-1} \frac{(m+a)_k(m+b)_k}{k!(1-m)_k} * - * @f] */ template _Tp __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { const _Tp __d = __c - __a - __b; const int __intd = std::floor(__d + _Tp(0.5L)); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __toler = _Tp(1000) * __eps; const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); const bool __d_integer = (std::abs(__d - __intd) < __toler); if (__d_integer) { const _Tp __ln_omx = std::log(_Tp(1) - __x); const _Tp __ad = std::abs(__d); _Tp __F1, __F2; _Tp __d1, __d2; if (__d >= _Tp(0)) { __d1 = __d; __d2 = _Tp(0); } else { __d1 = _Tp(0); __d2 = __d; } const _Tp __lng_c = __log_gamma(__c); // Evaluate F1. if (__ad < __eps) { // d = c - a - b = 0. __F1 = _Tp(0); } else { bool __ok_d1 = true; _Tp __lng_ad, __lng_ad1, __lng_bd1; __try { __lng_ad = __log_gamma(__ad); __lng_ad1 = __log_gamma(__a + __d1); __lng_bd1 = __log_gamma(__b + __d1); } __catch(...) { __ok_d1 = false; } if (__ok_d1) { /* Gamma functions in the denominator are ok. * Proceed with evaluation. */ _Tp __sum1 = _Tp(1); _Tp __term = _Tp(1); _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx - __lng_ad1 - __lng_bd1; /* Do F1 sum. */ for (int __i = 1; __i < __ad; ++__i) { const int __j = __i - 1; __term *= (__a + __d2 + __j) * (__b + __d2 + __j) / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); __sum1 += __term; } if (__ln_pre1 > __log_max) std::__throw_runtime_error(__N("Overflow of gamma functions" " in __hyperg_luke.")); else __F1 = std::exp(__ln_pre1) * __sum1; } else { // Gamma functions in the denominator were not ok. // So the F1 term is zero. __F1 = _Tp(0); } } // end F1 evaluation // Evaluate F2. bool __ok_d2 = true; _Tp __lng_ad2, __lng_bd2; __try { __lng_ad2 = __log_gamma(__a + __d2); __lng_bd2 = __log_gamma(__b + __d2); } __catch(...) { __ok_d2 = false; } if (__ok_d2) { // Gamma functions in the denominator are ok. // Proceed with evaluation. const int __maxiter = 2000; const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); const _Tp __psi_1pd = __psi(_Tp(1) + __ad); const _Tp __psi_apd1 = __psi(__a + __d1); const _Tp __psi_bpd1 = __psi(__b + __d1); _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 - __psi_bpd1 - __ln_omx; _Tp __fact = _Tp(1); _Tp __sum2 = __psi_term; _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx - __lng_ad2 - __lng_bd2; // Do F2 sum. int __j; for (__j = 1; __j < __maxiter; ++__j) { // Values for psi functions use recurrence; // Abramowitz & Stegun 6.3.5 const _Tp __term1 = _Tp(1) / _Tp(__j) + _Tp(1) / (__ad + __j); const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); __psi_term += __term1 - __term2; __fact *= (__a + __d1 + _Tp(__j - 1)) * (__b + __d1 + _Tp(__j - 1)) / ((__ad + __j) * __j) * (_Tp(1) - __x); const _Tp __delta = __fact * __psi_term; __sum2 += __delta; if (std::abs(__delta) < __eps * std::abs(__sum2)) break; } if (__j == __maxiter) std::__throw_runtime_error(__N("Sum F2 failed to converge " "in __hyperg_reflect")); if (__sum2 == _Tp(0)) __F2 = _Tp(0); else __F2 = std::exp(__ln_pre2) * __sum2; } else { // Gamma functions in the denominator not ok. // So the F2 term is zero. __F2 = _Tp(0); } // end F2 evaluation const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); const _Tp __F = __F1 + __sgn_2 * __F2; return __F; } else { // d = c - a - b not an integer. // These gamma functions appear in the denominator, so we // catch their harmless domain errors and set the terms to zero. bool __ok1 = true; _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); __try { __sgn_g1ca = __log_gamma_sign(__c - __a); __ln_g1ca = __log_gamma(__c - __a); __sgn_g1cb = __log_gamma_sign(__c - __b); __ln_g1cb = __log_gamma(__c - __b); } __catch(...) { __ok1 = false; } bool __ok2 = true; _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); __try { __sgn_g2a = __log_gamma_sign(__a); __ln_g2a = __log_gamma(__a); __sgn_g2b = __log_gamma_sign(__b); __ln_g2b = __log_gamma(__b); } __catch(...) { __ok2 = false; } const _Tp __sgn_gc = __log_gamma_sign(__c); const _Tp __ln_gc = __log_gamma(__c); const _Tp __sgn_gd = __log_gamma_sign(__d); const _Tp __ln_gd = __log_gamma(__d); const _Tp __sgn_gmd = __log_gamma_sign(-__d); const _Tp __ln_gmd = __log_gamma(-__d); const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; _Tp __pre1, __pre2; if (__ok1 && __ok2) { _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + __d * std::log(_Tp(1) - __x); if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) { __pre1 = std::exp(__ln_pre1); __pre2 = std::exp(__ln_pre2); __pre1 *= __sgn1; __pre2 *= __sgn2; } else { std::__throw_runtime_error(__N("Overflow of gamma functions " "in __hyperg_reflect")); } } else if (__ok1 && !__ok2) { _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; if (__ln_pre1 < __log_max) { __pre1 = std::exp(__ln_pre1); __pre1 *= __sgn1; __pre2 = _Tp(0); } else { std::__throw_runtime_error(__N("Overflow of gamma functions " "in __hyperg_reflect")); } } else if (!__ok1 && __ok2) { _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + __d * std::log(_Tp(1) - __x); if (__ln_pre2 < __log_max) { __pre1 = _Tp(0); __pre2 = std::exp(__ln_pre2); __pre2 *= __sgn2; } else { std::__throw_runtime_error(__N("Overflow of gamma functions " "in __hyperg_reflect")); } } else { __pre1 = _Tp(0); __pre2 = _Tp(0); std::__throw_runtime_error(__N("Underflow of gamma functions " "in __hyperg_reflect")); } const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, _Tp(1) - __x); const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, _Tp(1) - __x); const _Tp __F = __pre1 * __F1 + __pre2 * __F2; return __F; } } /** * @brief Return the hypogeometric function @f$ _2F_1(a,b;c;x) @f$. * * The hypogeometric function is defined by * @f[ * _2F_1(a,b;c;x) = \frac{\Gamma(c)}{\Gamma(a)\Gamma(b)} * \sum_{n=0}^{\infty} * \frac{\Gamma(a+n)\Gamma(b+n)}{\Gamma(c+n)} * \frac{x^n}{n!} * @f] * * @param __a The first @a numerator parameter. * @param __a The second @a numerator parameter. * @param __c The @a denominator parameter. * @param __x The argument of the confluent hypergeometric function. * @return The confluent hypergeometric function. */ template _Tp __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __a_nint = _GLIBCXX_MATH_NS::nearbyint(__a); const _Tp __b_nint = _GLIBCXX_MATH_NS::nearbyint(__b); const _Tp __c_nint = _GLIBCXX_MATH_NS::nearbyint(__c); #else const _Tp __a_nint = static_cast(__a + _Tp(0.5L)); const _Tp __b_nint = static_cast(__b + _Tp(0.5L)); const _Tp __c_nint = static_cast(__c + _Tp(0.5L)); #endif const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); if (std::abs(__x) >= _Tp(1)) std::__throw_domain_error(__N("Argument outside unit circle " "in __hyperg.")); else if (__isnan(__a) || __isnan(__b) || __isnan(__c) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__c_nint == __c && __c_nint <= _Tp(0)) return std::numeric_limits<_Tp>::infinity(); else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) return std::pow(_Tp(1) - __x, __c - __a - __b); else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) && __x >= _Tp(0) && __x < _Tp(0.995L)) return __hyperg_series(__a, __b, __c, __x); else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) { // For integer a and b the hypergeometric function is a // finite polynomial. if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) return __hyperg_series(__a_nint, __b, __c, __x); else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) return __hyperg_series(__a, __b_nint, __c, __x); else if (__x < -_Tp(0.25L)) return __hyperg_luke(__a, __b, __c, __x); else if (__x < _Tp(0.5L)) return __hyperg_series(__a, __b, __c, __x); else if (std::abs(__c) > _Tp(10)) return __hyperg_series(__a, __b, __c, __x); else return __hyperg_reflect(__a, __b, __c, __x); } else return __hyperg_luke(__a, __b, __c, __x); } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC c++/8/tr1/cinttypes000064400000004320152640040170007734 0ustar00// TR1 cinttypes -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cinttypes * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CINTTYPES #define _GLIBCXX_TR1_CINTTYPES 1 #pragma GCC system_header #include // For 8.11.1/1 (see C99, Note 184) #if _GLIBCXX_HAVE_INTTYPES_H # ifndef __STDC_FORMAT_MACROS # define _UNDEF__STDC_FORMAT_MACROS # define __STDC_FORMAT_MACROS # endif # include # ifdef _UNDEF__STDC_FORMAT_MACROS # undef __STDC_FORMAT_MACROS # undef _UNDEF__STDC_FORMAT_MACROS # endif #endif #ifdef _GLIBCXX_USE_C99_INTTYPES_TR1 namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { // types using ::imaxdiv_t; // functions using ::imaxabs; // May collide with _Longlong abs(_Longlong), and is not described // anywhere outside the synopsis. Likely, a defect. // // intmax_t abs(intmax_t) using ::imaxdiv; // Likewise, with lldiv_t div(_Longlong, _Longlong). // // imaxdiv_t div(intmax_t, intmax_t) using ::strtoimax; using ::strtoumax; #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 using ::wcstoimax; using ::wcstoumax; #endif } } #endif // _GLIBCXX_USE_C99_INTTYPES_TR1 #endif // _GLIBCXX_TR1_CINTTYPES c++/8/tr1/functional000064400000211621152640040170010060 0ustar00// TR1 functional header -*- C++ -*- // Copyright (C) 2004-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/functional * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_FUNCTIONAL #define _GLIBCXX_TR1_FUNCTIONAL 1 #pragma GCC system_header #include #include #include #include #include #include #include #include #include #include // for std::__addressof #if __cplusplus >= 201103L # include // for integral_constant, true_type, false_type #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus >= 201103L template struct _Placeholder; template class _Bind; template class _Bind_result; #endif namespace tr1 { template class _Mem_fn; template _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::*); /** * Actual implementation of _Has_result_type, which uses SFINAE to * determine if the type _Tp has a publicly-accessible member type * result_type. */ template class _Has_result_type_helper : __sfinae_types { template struct _Wrap_type { }; template static __one __test(_Wrap_type*); template static __two __test(...); public: static const bool value = sizeof(__test<_Tp>(0)) == 1; }; template struct _Has_result_type : integral_constant::type>::value> { }; /** * */ /// If we have found a result_type, extract it. template struct _Maybe_get_result_type { }; template struct _Maybe_get_result_type { typedef typename _Functor::result_type result_type; }; /** * Base class for any function object that has a weak result type, as * defined in 3.3/3 of TR1. */ template struct _Weak_result_type_impl : _Maybe_get_result_type<_Has_result_type<_Functor>::value, _Functor> { }; /// Retrieve the result type for a function type. template struct _Weak_result_type_impl<_Res(_ArgTypes...)> { typedef _Res result_type; }; /// Retrieve the result type for a function reference. template struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> { typedef _Res result_type; }; /// Retrieve the result type for a function pointer. template struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> { typedef _Res result_type; }; /// Retrieve result type for a member function pointer. template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> { typedef _Res result_type; }; /// Retrieve result type for a const member function pointer. template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> { typedef _Res result_type; }; /// Retrieve result type for a volatile member function pointer. template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> { typedef _Res result_type; }; /// Retrieve result type for a const volatile member function pointer. template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)const volatile> { typedef _Res result_type; }; /** * Strip top-level cv-qualifiers from the function object and let * _Weak_result_type_impl perform the real work. */ template struct _Weak_result_type : _Weak_result_type_impl::type> { }; template class result_of; /** * Actual implementation of result_of. When _Has_result_type is * true, gets its result from _Weak_result_type. Otherwise, uses * the function object's member template result to extract the * result type. */ template struct _Result_of_impl; // Handle member data pointers using _Mem_fn's logic template struct _Result_of_impl { typedef typename _Mem_fn<_Res _Class::*> ::template _Result_type<_T1>::type type; }; /** * Determine whether we can determine a result type from @c Functor * alone. */ template class result_of<_Functor(_ArgTypes...)> : public _Result_of_impl< _Has_result_type<_Weak_result_type<_Functor> >::value, _Functor(_ArgTypes...)> { }; /// We already know the result type for @c Functor; use it. template struct _Result_of_impl { typedef typename _Weak_result_type<_Functor>::result_type type; }; /** * We need to compute the result type for this invocation the hard * way. */ template struct _Result_of_impl { typedef typename _Functor ::template result<_Functor(_ArgTypes...)>::type type; }; /** * It is unsafe to access ::result when there are zero arguments, so we * return @c void instead. */ template struct _Result_of_impl { typedef void type; }; /// Determines if the type _Tp derives from unary_function. template struct _Derives_from_unary_function : __sfinae_types { private: template static __one __test(const volatile unary_function<_T1, _Res>*); // It's tempting to change "..." to const volatile void*, but // that fails when _Tp is a function type. static __two __test(...); public: static const bool value = sizeof(__test((_Tp*)0)) == 1; }; /// Determines if the type _Tp derives from binary_function. template struct _Derives_from_binary_function : __sfinae_types { private: template static __one __test(const volatile binary_function<_T1, _T2, _Res>*); // It's tempting to change "..." to const volatile void*, but // that fails when _Tp is a function type. static __two __test(...); public: static const bool value = sizeof(__test((_Tp*)0)) == 1; }; /// Turns a function type into a function pointer type template::value> struct _Function_to_function_pointer { typedef _Tp type; }; template struct _Function_to_function_pointer<_Tp, true> { typedef _Tp* type; }; /** * Invoke a function object, which may be either a member pointer or a * function object. The first parameter will tell which. */ template inline typename __gnu_cxx::__enable_if< (!is_member_pointer<_Functor>::value && !is_function<_Functor>::value && !is_function::type>::value), typename result_of<_Functor(_Args...)>::type >::__type __invoke(_Functor& __f, _Args&... __args) { return __f(__args...); } template inline typename __gnu_cxx::__enable_if< (is_member_pointer<_Functor>::value && !is_function<_Functor>::value && !is_function::type>::value), typename result_of<_Functor(_Args...)>::type >::__type __invoke(_Functor& __f, _Args&... __args) { return mem_fn(__f)(__args...); } // To pick up function references (that will become function pointers) template inline typename __gnu_cxx::__enable_if< (is_pointer<_Functor>::value && is_function::type>::value), typename result_of<_Functor(_Args...)>::type >::__type __invoke(_Functor __f, _Args&... __args) { return __f(__args...); } /** * Knowing which of unary_function and binary_function _Tp derives * from, derives from the same and ensures that reference_wrapper * will have a weak result type. See cases below. */ template struct _Reference_wrapper_base_impl; // Not a unary_function or binary_function, so try a weak result type. template struct _Reference_wrapper_base_impl : _Weak_result_type<_Tp> { }; // unary_function but not binary_function template struct _Reference_wrapper_base_impl : unary_function { }; // binary_function but not unary_function template struct _Reference_wrapper_base_impl : binary_function { }; // Both unary_function and binary_function. Import result_type to // avoid conflicts. template struct _Reference_wrapper_base_impl : unary_function, binary_function { typedef typename _Tp::result_type result_type; }; /** * Derives from unary_function or binary_function when it * can. Specializations handle all of the easy cases. The primary * template determines what to do with a class type, which may * derive from both unary_function and binary_function. */ template struct _Reference_wrapper_base : _Reference_wrapper_base_impl< _Derives_from_unary_function<_Tp>::value, _Derives_from_binary_function<_Tp>::value, _Tp> { }; // - a function type (unary) template struct _Reference_wrapper_base<_Res(_T1)> : unary_function<_T1, _Res> { }; // - a function type (binary) template struct _Reference_wrapper_base<_Res(_T1, _T2)> : binary_function<_T1, _T2, _Res> { }; // - a function pointer type (unary) template struct _Reference_wrapper_base<_Res(*)(_T1)> : unary_function<_T1, _Res> { }; // - a function pointer type (binary) template struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> : binary_function<_T1, _T2, _Res> { }; // - a pointer to member function type (unary, no qualifiers) template struct _Reference_wrapper_base<_Res (_T1::*)()> : unary_function<_T1*, _Res> { }; // - a pointer to member function type (binary, no qualifiers) template struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> : binary_function<_T1*, _T2, _Res> { }; // - a pointer to member function type (unary, const) template struct _Reference_wrapper_base<_Res (_T1::*)() const> : unary_function { }; // - a pointer to member function type (binary, const) template struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> : binary_function { }; // - a pointer to member function type (unary, volatile) template struct _Reference_wrapper_base<_Res (_T1::*)() volatile> : unary_function { }; // - a pointer to member function type (binary, volatile) template struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> : binary_function { }; // - a pointer to member function type (unary, const volatile) template struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> : unary_function { }; // - a pointer to member function type (binary, const volatile) template struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> : binary_function { }; /// reference_wrapper template class reference_wrapper : public _Reference_wrapper_base::type> { // If _Tp is a function type, we can't form result_of<_Tp(...)>, // so turn it into a function pointer type. typedef typename _Function_to_function_pointer<_Tp>::type _M_func_type; _Tp* _M_data; public: typedef _Tp type; explicit reference_wrapper(_Tp& __indata) : _M_data(std::__addressof(__indata)) { } reference_wrapper(const reference_wrapper<_Tp>& __inref): _M_data(__inref._M_data) { } reference_wrapper& operator=(const reference_wrapper<_Tp>& __inref) { _M_data = __inref._M_data; return *this; } operator _Tp&() const { return this->get(); } _Tp& get() const { return *_M_data; } template typename result_of<_M_func_type(_Args...)>::type operator()(_Args&... __args) const { return __invoke(get(), __args...); } }; // Denotes a reference should be taken to a variable. template inline reference_wrapper<_Tp> ref(_Tp& __t) { return reference_wrapper<_Tp>(__t); } // Denotes a const reference should be taken to a variable. template inline reference_wrapper cref(const _Tp& __t) { return reference_wrapper(__t); } template inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) { return ref(__t.get()); } template inline reference_wrapper cref(reference_wrapper<_Tp> __t) { return cref(__t.get()); } template struct _Mem_fn_const_or_non { typedef const _Tp& type; }; template struct _Mem_fn_const_or_non<_Tp, false> { typedef _Tp& type; }; /** * Derives from @c unary_function or @c binary_function, or perhaps * nothing, depending on the number of arguments provided. The * primary template is the basis case, which derives nothing. */ template struct _Maybe_unary_or_binary_function { }; /// Derives from @c unary_function, as appropriate. template struct _Maybe_unary_or_binary_function<_Res, _T1> : std::unary_function<_T1, _Res> { }; /// Derives from @c binary_function, as appropriate. template struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> : std::binary_function<_T1, _T2, _Res> { }; /// Implementation of @c mem_fn for member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...); template _Res _M_call(_Tp& __object, const volatile _Class *, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } template _Res _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const { return ((*__ptr).*__pmf)(__args...); } public: typedef _Res result_type; explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } // Handle objects _Res operator()(_Class& __object, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } // Handle pointers _Res operator()(_Class* __object, _ArgTypes... __args) const { return (__object->*__pmf)(__args...); } // Handle smart pointers, references and pointers to derived template _Res operator()(_Tp& __object, _ArgTypes... __args) const { return _M_call(__object, &__object, __args...); } private: _Functor __pmf; }; /// Implementation of @c mem_fn for const member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> : public _Maybe_unary_or_binary_function<_Res, const _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) const; template _Res _M_call(_Tp& __object, const volatile _Class *, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } template _Res _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const { return ((*__ptr).*__pmf)(__args...); } public: typedef _Res result_type; explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } // Handle objects _Res operator()(const _Class& __object, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } // Handle pointers _Res operator()(const _Class* __object, _ArgTypes... __args) const { return (__object->*__pmf)(__args...); } // Handle smart pointers, references and pointers to derived template _Res operator()(_Tp& __object, _ArgTypes... __args) const { return _M_call(__object, &__object, __args...); } private: _Functor __pmf; }; /// Implementation of @c mem_fn for volatile member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; template _Res _M_call(_Tp& __object, const volatile _Class *, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } template _Res _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const { return ((*__ptr).*__pmf)(__args...); } public: typedef _Res result_type; explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } // Handle objects _Res operator()(volatile _Class& __object, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } // Handle pointers _Res operator()(volatile _Class* __object, _ArgTypes... __args) const { return (__object->*__pmf)(__args...); } // Handle smart pointers, references and pointers to derived template _Res operator()(_Tp& __object, _ArgTypes... __args) const { return _M_call(__object, &__object, __args...); } private: _Functor __pmf; }; /// Implementation of @c mem_fn for const volatile member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; template _Res _M_call(_Tp& __object, const volatile _Class *, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } template _Res _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const { return ((*__ptr).*__pmf)(__args...); } public: typedef _Res result_type; explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } // Handle objects _Res operator()(const volatile _Class& __object, _ArgTypes... __args) const { return (__object.*__pmf)(__args...); } // Handle pointers _Res operator()(const volatile _Class* __object, _ArgTypes... __args) const { return (__object->*__pmf)(__args...); } // Handle smart pointers, references and pointers to derived template _Res operator()(_Tp& __object, _ArgTypes... __args) const { return _M_call(__object, &__object, __args...); } private: _Functor __pmf; }; template class _Mem_fn<_Res _Class::*> { // This bit of genius is due to Peter Dimov, improved slightly by // Douglas Gregor. template _Res& _M_call(_Tp& __object, _Class *) const { return __object.*__pm; } template _Res& _M_call(_Tp& __object, _Up * const *) const { return (*__object).*__pm; } template const _Res& _M_call(_Tp& __object, const _Up * const *) const { return (*__object).*__pm; } template const _Res& _M_call(_Tp& __object, const _Class *) const { return __object.*__pm; } template const _Res& _M_call(_Tp& __ptr, const volatile void*) const { return (*__ptr).*__pm; } template static _Tp& __get_ref(); template static __sfinae_types::__one __check_const(_Tp&, _Class*); template static __sfinae_types::__one __check_const(_Tp&, _Up * const *); template static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); template static __sfinae_types::__two __check_const(_Tp&, const _Class*); template static __sfinae_types::__two __check_const(_Tp&, const volatile void*); public: template struct _Result_type : _Mem_fn_const_or_non<_Res, (sizeof(__sfinae_types::__two) == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> { }; template struct result; template struct result<_CVMem(_Tp)> : public _Result_type<_Tp> { }; template struct result<_CVMem(_Tp&)> : public _Result_type<_Tp> { }; explicit _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { } // Handle objects _Res& operator()(_Class& __object) const { return __object.*__pm; } const _Res& operator()(const _Class& __object) const { return __object.*__pm; } // Handle pointers _Res& operator()(_Class* __object) const { return __object->*__pm; } const _Res& operator()(const _Class* __object) const { return __object->*__pm; } // Handle smart pointers and derived template typename _Result_type<_Tp>::type operator()(_Tp& __unknown) const { return _M_call(__unknown, &__unknown); } private: _Res _Class::*__pm; }; /** * @brief Returns a function object that forwards to the member * pointer @a pm. */ template inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::* __pm) { return _Mem_fn<_Tp _Class::*>(__pm); } /** * @brief Determines if the given type _Tp is a function object * should be treated as a subexpression when evaluating calls to * function objects returned by bind(). [TR1 3.6.1] */ template struct is_bind_expression { static const bool value = false; }; template const bool is_bind_expression<_Tp>::value; /** * @brief Determines if the given type _Tp is a placeholder in a * bind() expression and, if so, which placeholder it is. [TR1 3.6.2] */ template struct is_placeholder { static const int value = 0; }; template const int is_placeholder<_Tp>::value; /// The type of placeholder objects defined by libstdc++. template struct _Placeholder { }; /** @namespace std::tr1::placeholders * @brief Sub-namespace for tr1/functional. */ namespace placeholders { /* Define a large number of placeholders. There is no way to * simplify this with variadic templates, because we're introducing * unique names for each. */ namespace { _Placeholder<1> _1; _Placeholder<2> _2; _Placeholder<3> _3; _Placeholder<4> _4; _Placeholder<5> _5; _Placeholder<6> _6; _Placeholder<7> _7; _Placeholder<8> _8; _Placeholder<9> _9; _Placeholder<10> _10; _Placeholder<11> _11; _Placeholder<12> _12; _Placeholder<13> _13; _Placeholder<14> _14; _Placeholder<15> _15; _Placeholder<16> _16; _Placeholder<17> _17; _Placeholder<18> _18; _Placeholder<19> _19; _Placeholder<20> _20; _Placeholder<21> _21; _Placeholder<22> _22; _Placeholder<23> _23; _Placeholder<24> _24; _Placeholder<25> _25; _Placeholder<26> _26; _Placeholder<27> _27; _Placeholder<28> _28; _Placeholder<29> _29; } } /** * Partial specialization of is_placeholder that provides the placeholder * number for the placeholder objects defined by libstdc++. */ template struct is_placeholder<_Placeholder<_Num> > { static const int value = _Num; }; template const int is_placeholder<_Placeholder<_Num> >::value; #if __cplusplus >= 201103L template struct is_placeholder> : std::integral_constant { }; template struct is_placeholder> : std::integral_constant { }; #endif /** * Stores a tuple of indices. Used by bind() to extract the elements * in a tuple. */ template struct _Index_tuple { }; /// Builds an _Index_tuple<0, 1, 2, ..., _Num-1>. template > struct _Build_index_tuple; template struct _Build_index_tuple<_Num, _Index_tuple<_Indexes...> > : _Build_index_tuple<_Num - 1, _Index_tuple<_Indexes..., sizeof...(_Indexes)> > { }; template struct _Build_index_tuple<0, _Index_tuple<_Indexes...> > { typedef _Index_tuple<_Indexes...> __type; }; /** * Used by _Safe_tuple_element to indicate that there is no tuple * element at this position. */ struct _No_tuple_element; /** * Implementation helper for _Safe_tuple_element. This primary * template handles the case where it is safe to use @c * tuple_element. */ template struct _Safe_tuple_element_impl : tuple_element<__i, _Tuple> { }; /** * Implementation helper for _Safe_tuple_element. This partial * specialization handles the case where it is not safe to use @c * tuple_element. We just return @c _No_tuple_element. */ template struct _Safe_tuple_element_impl<__i, _Tuple, false> { typedef _No_tuple_element type; }; /** * Like tuple_element, but returns @c _No_tuple_element when * tuple_element would return an error. */ template struct _Safe_tuple_element : _Safe_tuple_element_impl<__i, _Tuple, (__i >= 0 && __i < tuple_size<_Tuple>::value)> { }; /** * Maps an argument to bind() into an actual argument to the bound * function object [TR1 3.6.3/5]. Only the first parameter should * be specified: the rest are used to determine among the various * implementations. Note that, although this class is a function * object, it isn't entirely normal because it takes only two * parameters regardless of the number of parameters passed to the * bind expression. The first parameter is the bound argument and * the second parameter is a tuple containing references to the * rest of the arguments. */ template::value, bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> class _Mu; /** * If the argument is reference_wrapper<_Tp>, returns the * underlying reference. [TR1 3.6.3/5 bullet 1] */ template class _Mu, false, false> { public: typedef _Tp& result_type; /* Note: This won't actually work for const volatile * reference_wrappers, because reference_wrapper::get() is const * but not volatile-qualified. This might be a defect in the TR. */ template result_type operator()(_CVRef& __arg, const _Tuple&) const volatile { return __arg.get(); } }; /** * If the argument is a bind expression, we invoke the underlying * function object with the same cv-qualifiers as we are given and * pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2] */ template class _Mu<_Arg, true, false> { public: template class result; // Determine the result type when we pass the arguments along. This // involves passing along the cv-qualifiers placed on _Mu and // unwrapping the argument bundle. template class result<_CVMu(_CVArg, tuple<_Args...>)> : public result_of<_CVArg(_Args...)> { }; template typename result_of<_CVArg(_Args...)>::type operator()(_CVArg& __arg, const tuple<_Args...>& __tuple) const volatile { // Construct an index tuple and forward to __call typedef typename _Build_index_tuple::__type _Indexes; return this->__call(__arg, __tuple, _Indexes()); } private: // Invokes the underlying function object __arg by unpacking all // of the arguments in the tuple. template typename result_of<_CVArg(_Args...)>::type __call(_CVArg& __arg, const tuple<_Args...>& __tuple, const _Index_tuple<_Indexes...>&) const volatile { return __arg(tr1::get<_Indexes>(__tuple)...); } }; /** * If the argument is a placeholder for the Nth argument, returns * a reference to the Nth argument to the bind function object. * [TR1 3.6.3/5 bullet 3] */ template class _Mu<_Arg, false, true> { public: template class result; template class result<_CVMu(_CVArg, _Tuple)> { // Add a reference, if it hasn't already been done for us. // This allows us to be a little bit sloppy in constructing // the tuple that we pass to result_of<...>. typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value - 1), _Tuple>::type __base_type; public: typedef typename add_reference<__base_type>::type type; }; template typename result<_Mu(_Arg, _Tuple)>::type operator()(const volatile _Arg&, const _Tuple& __tuple) const volatile { return ::std::tr1::get<(is_placeholder<_Arg>::value - 1)>(__tuple); } }; /** * If the argument is just a value, returns a reference to that * value. The cv-qualifiers on the reference are the same as the * cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4] */ template class _Mu<_Arg, false, false> { public: template struct result; template struct result<_CVMu(_CVArg, _Tuple)> { typedef typename add_reference<_CVArg>::type type; }; // Pick up the cv-qualifiers of the argument template _CVArg& operator()(_CVArg& __arg, const _Tuple&) const volatile { return __arg; } }; /** * Maps member pointers into instances of _Mem_fn but leaves all * other function objects untouched. Used by tr1::bind(). The * primary template handles the non--member-pointer case. */ template struct _Maybe_wrap_member_pointer { typedef _Tp type; static const _Tp& __do_wrap(const _Tp& __x) { return __x; } }; /** * Maps member pointers into instances of _Mem_fn but leaves all * other function objects untouched. Used by tr1::bind(). This * partial specialization handles the member pointer case. */ template struct _Maybe_wrap_member_pointer<_Tp _Class::*> { typedef _Mem_fn<_Tp _Class::*> type; static type __do_wrap(_Tp _Class::* __pm) { return type(__pm); } }; /// Type of the function object returned from bind(). template struct _Bind; template class _Bind<_Functor(_Bound_args...)> : public _Weak_result_type<_Functor> { typedef _Bind __self_type; typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // Call unqualified template typename result_of< _Functor(typename result_of<_Mu<_Bound_args> (_Bound_args, tuple<_Args...>)>::type...) >::type __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as const template typename result_of< const _Functor(typename result_of<_Mu<_Bound_args> (const _Bound_args, tuple<_Args...>) >::type...)>::type __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as volatile template typename result_of< volatile _Functor(typename result_of<_Mu<_Bound_args> (volatile _Bound_args, tuple<_Args...>) >::type...)>::type __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) volatile { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as const volatile template typename result_of< const volatile _Functor(typename result_of<_Mu<_Bound_args> (const volatile _Bound_args, tuple<_Args...>) >::type...)>::type __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const volatile { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } public: explicit _Bind(_Functor __f, _Bound_args... __bound_args) : _M_f(__f), _M_bound_args(__bound_args...) { } // Call unqualified template typename result_of< _Functor(typename result_of<_Mu<_Bound_args> (_Bound_args, tuple<_Args...>)>::type...) >::type operator()(_Args&... __args) { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as const template typename result_of< const _Functor(typename result_of<_Mu<_Bound_args> (const _Bound_args, tuple<_Args...>)>::type...) >::type operator()(_Args&... __args) const { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as volatile template typename result_of< volatile _Functor(typename result_of<_Mu<_Bound_args> (volatile _Bound_args, tuple<_Args...>)>::type...) >::type operator()(_Args&... __args) volatile { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as const volatile template typename result_of< const volatile _Functor(typename result_of<_Mu<_Bound_args> (const volatile _Bound_args, tuple<_Args...>)>::type...) >::type operator()(_Args&... __args) const volatile { return this->__call(tr1::tie(__args...), _Bound_indexes()); } }; /// Type of the function object returned from bind(). template struct _Bind_result; template class _Bind_result<_Result, _Functor(_Bound_args...)> { typedef _Bind_result __self_type; typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // Call unqualified template _Result __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as const template _Result __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as volatile template _Result __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) volatile { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } // Call as const volatile template _Result __call(const tuple<_Args...>& __args, _Index_tuple<_Indexes...>) const volatile { return _M_f(_Mu<_Bound_args>() (tr1::get<_Indexes>(_M_bound_args), __args)...); } public: typedef _Result result_type; explicit _Bind_result(_Functor __f, _Bound_args... __bound_args) : _M_f(__f), _M_bound_args(__bound_args...) { } // Call unqualified template result_type operator()(_Args&... __args) { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as const template result_type operator()(_Args&... __args) const { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as volatile template result_type operator()(_Args&... __args) volatile { return this->__call(tr1::tie(__args...), _Bound_indexes()); } // Call as const volatile template result_type operator()(_Args&... __args) const volatile { return this->__call(tr1::tie(__args...), _Bound_indexes()); } }; /// Class template _Bind is always a bind expression. template struct is_bind_expression<_Bind<_Signature> > { static const bool value = true; }; template const bool is_bind_expression<_Bind<_Signature> >::value; /// Class template _Bind is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; /// Class template _Bind is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; /// Class template _Bind is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; /// Class template _Bind_result is always a bind expression. template struct is_bind_expression<_Bind_result<_Result, _Signature> > { static const bool value = true; }; template const bool is_bind_expression<_Bind_result<_Result, _Signature> >::value; /// Class template _Bind_result is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; /// Class template _Bind_result is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; /// Class template _Bind_result is always a bind expression. template struct is_bind_expression > { static const bool value = true; }; template const bool is_bind_expression >::value; #if __cplusplus >= 201103L template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; #endif /// bind template inline _Bind::type(_ArgTypes...)> bind(_Functor __f, _ArgTypes... __args) { typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; typedef typename __maybe_type::type __functor_type; typedef _Bind<__functor_type(_ArgTypes...)> __result_type; return __result_type(__maybe_type::__do_wrap(__f), __args...); } template inline _Bind_result<_Result, typename _Maybe_wrap_member_pointer<_Functor>::type (_ArgTypes...)> bind(_Functor __f, _ArgTypes... __args) { typedef _Maybe_wrap_member_pointer<_Functor> __maybe_type; typedef typename __maybe_type::type __functor_type; typedef _Bind_result<_Result, __functor_type(_ArgTypes...)> __result_type; return __result_type(__maybe_type::__do_wrap(__f), __args...); } /** * @brief Exception class thrown when class template function's * operator() is called with an empty target. * @ingroup exceptions */ class bad_function_call : public std::exception { }; /** * The integral constant expression 0 can be converted into a * pointer to this type. It is used by the function template to * accept NULL pointers. */ struct _M_clear_type; /** * Trait identifying @a location-invariant types, meaning that the * address of the object (or any of its members) will not escape. * Also implies a trivial copy constructor and assignment operator. */ template struct __is_location_invariant : integral_constant::value || is_member_pointer<_Tp>::value)> { }; class _Undefined_class; union _Nocopy_types { void* _M_object; const void* _M_const_object; void (*_M_function_pointer)(); void (_Undefined_class::*_M_member_pointer)(); }; union _Any_data { void* _M_access() { return &_M_pod_data[0]; } const void* _M_access() const { return &_M_pod_data[0]; } template _Tp& _M_access() { return *static_cast<_Tp*>(_M_access()); } template const _Tp& _M_access() const { return *static_cast(_M_access()); } _Nocopy_types _M_unused; char _M_pod_data[sizeof(_Nocopy_types)]; }; enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; // Simple type wrapper that helps avoid annoying const problems // when casting between void pointers and pointers-to-pointers. template struct _Simple_type_wrapper { _Simple_type_wrapper(_Tp __value) : __value(__value) { } _Tp __value; }; template struct __is_location_invariant<_Simple_type_wrapper<_Tp> > : __is_location_invariant<_Tp> { }; // Converts a reference to a function object into a callable // function object. template inline _Functor& __callable_functor(_Functor& __f) { return __f; } template inline _Mem_fn<_Member _Class::*> __callable_functor(_Member _Class::* &__p) { return mem_fn(__p); } template inline _Mem_fn<_Member _Class::*> __callable_functor(_Member _Class::* const &__p) { return mem_fn(__p); } template class function; /// Base class of all polymorphic function object wrappers. class _Function_base { public: static const std::size_t _M_max_size = sizeof(_Nocopy_types); static const std::size_t _M_max_align = __alignof__(_Nocopy_types); template class _Base_manager { protected: static const bool __stored_locally = (__is_location_invariant<_Functor>::value && sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); typedef integral_constant _Local_storage; // Retrieve a pointer to the function object static _Functor* _M_get_pointer(const _Any_data& __source) { const _Functor* __ptr = __stored_locally? std::__addressof(__source._M_access<_Functor>()) /* have stored a pointer */ : __source._M_access<_Functor*>(); return const_cast<_Functor*>(__ptr); } // Clone a location-invariant function object that fits within // an _Any_data structure. static void _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) { new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); } // Clone a function object that is not location-invariant or // that cannot fit into an _Any_data structure. static void _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) { __dest._M_access<_Functor*>() = new _Functor(*__source._M_access<_Functor*>()); } // Destroying a location-invariant object may still require // destruction. static void _M_destroy(_Any_data& __victim, true_type) { __victim._M_access<_Functor>().~_Functor(); } // Destroying an object located on the heap. static void _M_destroy(_Any_data& __victim, false_type) { delete __victim._M_access<_Functor*>(); } public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { #if __cpp_rtti case __get_type_info: __dest._M_access() = &typeid(_Functor); break; #endif case __get_functor_ptr: __dest._M_access<_Functor*>() = _M_get_pointer(__source); break; case __clone_functor: _M_clone(__dest, __source, _Local_storage()); break; case __destroy_functor: _M_destroy(__dest, _Local_storage()); break; } return false; } static void _M_init_functor(_Any_data& __functor, const _Functor& __f) { _M_init_functor(__functor, __f, _Local_storage()); } template static bool _M_not_empty_function(const function<_Signature>& __f) { return static_cast(__f); } template static bool _M_not_empty_function(const _Tp*& __fp) { return __fp; } template static bool _M_not_empty_function(_Tp _Class::* const& __mp) { return __mp; } template static bool _M_not_empty_function(const _Tp&) { return true; } private: static void _M_init_functor(_Any_data& __functor, const _Functor& __f, true_type) { new (__functor._M_access()) _Functor(__f); } static void _M_init_functor(_Any_data& __functor, const _Functor& __f, false_type) { __functor._M_access<_Functor*>() = new _Functor(__f); } }; template class _Ref_manager : public _Base_manager<_Functor*> { typedef _Function_base::_Base_manager<_Functor*> _Base; public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { #if __cpp_rtti case __get_type_info: __dest._M_access() = &typeid(_Functor); break; #endif case __get_functor_ptr: __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); return is_const<_Functor>::value; break; default: _Base::_M_manager(__dest, __source, __op); } return false; } static void _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f) { _Base::_M_init_functor(__functor, std::__addressof(__f.get())); } }; _Function_base() : _M_manager(0) { } ~_Function_base() { if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); } bool _M_empty() const { return !_M_manager; } typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, _Manager_operation); _Any_data _M_functor; _Manager_type _M_manager; }; template class _Function_handler; template class _Function_handler<_Res(_ArgTypes...), _Functor> : public _Function_base::_Base_manager<_Functor> { typedef _Function_base::_Base_manager<_Functor> _Base; public: static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { return (*_Base::_M_get_pointer(__functor))(__args...); } }; template class _Function_handler : public _Function_base::_Base_manager<_Functor> { typedef _Function_base::_Base_manager<_Functor> _Base; public: static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { (*_Base::_M_get_pointer(__functor))(__args...); } }; template class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> > : public _Function_base::_Ref_manager<_Functor> { typedef _Function_base::_Ref_manager<_Functor> _Base; public: static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { return __callable_functor(**_Base::_M_get_pointer(__functor))(__args...); } }; template class _Function_handler > : public _Function_base::_Ref_manager<_Functor> { typedef _Function_base::_Ref_manager<_Functor> _Base; public: static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { __callable_functor(**_Base::_M_get_pointer(__functor))(__args...); } }; template class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> : public _Function_handler { typedef _Function_handler _Base; public: static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { return tr1:: mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...); } }; template class _Function_handler : public _Function_base::_Base_manager< _Simple_type_wrapper< _Member _Class::* > > { typedef _Member _Class::* _Functor; typedef _Simple_type_wrapper<_Functor> _Wrapper; typedef _Function_base::_Base_manager<_Wrapper> _Base; public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { #if __cpp_rtti case __get_type_info: __dest._M_access() = &typeid(_Functor); break; #endif case __get_functor_ptr: __dest._M_access<_Functor*>() = &_Base::_M_get_pointer(__source)->__value; break; default: _Base::_M_manager(__dest, __source, __op); } return false; } static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { tr1::mem_fn(_Base::_M_get_pointer(__functor)->__value)(__args...); } }; /// class function template class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { #if __cplusplus < 201103L /// This class is used to implement the safe_bool idiom. struct _Hidden_type { _Hidden_type* _M_bool; }; /// This typedef is used to implement the safe_bool idiom. typedef _Hidden_type* _Hidden_type::* _Safe_bool; #endif typedef _Res _Signature_type(_ArgTypes...); struct _Useless { }; public: typedef _Res result_type; // [3.7.2.1] construct/copy/destroy /** * @brief Default construct creates an empty function call wrapper. * @post @c !(bool)*this */ function() : _Function_base() { } /** * @brief Default construct creates an empty function call wrapper. * @post @c !(bool)*this */ function(_M_clear_type*) : _Function_base() { } /** * @brief %Function copy constructor. * @param x A %function object with identical call signature. * @post @c (bool)*this == (bool)x * * The newly-created %function contains a copy of the target of @a * x (if it has one). */ function(const function& __x); /** * @brief Builds a %function that targets a copy of the incoming * function object. * @param f A %function object that is callable with parameters of * type @c T1, @c T2, ..., @c TN and returns a value convertible * to @c Res. * * The newly-created %function object will target a copy of @a * f. If @a f is @c reference_wrapper, then this function * object will contain a reference to the function object @c * f.get(). If @a f is a NULL function pointer or NULL * pointer-to-member, the newly-created object will be empty. * * If @a f is a non-NULL function pointer or an object of type @c * reference_wrapper, this function will not throw. */ template function(_Functor __f, typename __gnu_cxx::__enable_if< !is_integral<_Functor>::value, _Useless>::__type = _Useless()); /** * @brief %Function assignment operator. * @param x A %function with identical call signature. * @post @c (bool)*this == (bool)x * @returns @c *this * * The target of @a x is copied to @c *this. If @a x has no * target, then @c *this will be empty. * * If @a x targets a function pointer or a reference to a function * object, then this operation will not throw an %exception. */ function& operator=(const function& __x) { function(__x).swap(*this); return *this; } /** * @brief %Function assignment to zero. * @post @c !(bool)*this * @returns @c *this * * The target of @c *this is deallocated, leaving it empty. */ function& operator=(_M_clear_type*) { if (_M_manager) { _M_manager(_M_functor, _M_functor, __destroy_functor); _M_manager = 0; _M_invoker = 0; } return *this; } /** * @brief %Function assignment to a new target. * @param f A %function object that is callable with parameters of * type @c T1, @c T2, ..., @c TN and returns a value convertible * to @c Res. * @return @c *this * * This %function object wrapper will target a copy of @a * f. If @a f is @c reference_wrapper, then this function * object will contain a reference to the function object @c * f.get(). If @a f is a NULL function pointer or NULL * pointer-to-member, @c this object will be empty. * * If @a f is a non-NULL function pointer or an object of type @c * reference_wrapper, this function will not throw. */ template typename __gnu_cxx::__enable_if::value, function&>::__type operator=(_Functor __f) { function(__f).swap(*this); return *this; } // [3.7.2.2] function modifiers /** * @brief Swap the targets of two %function objects. * @param f A %function with identical call signature. * * Swap the targets of @c this function object and @a f. This * function will not throw an %exception. */ void swap(function& __x) { std::swap(_M_functor, __x._M_functor); std::swap(_M_manager, __x._M_manager); std::swap(_M_invoker, __x._M_invoker); } // [3.7.2.3] function capacity /** * @brief Determine if the %function wrapper has a target. * * @return @c true when this %function object contains a target, * or @c false when it is empty. * * This function will not throw an %exception. */ #if __cplusplus >= 201103L explicit operator bool() const { return !_M_empty(); } #else operator _Safe_bool() const { if (_M_empty()) return 0; else return &_Hidden_type::_M_bool; } #endif // [3.7.2.4] function invocation /** * @brief Invokes the function targeted by @c *this. * @returns the result of the target. * @throws bad_function_call when @c !(bool)*this * * The function call operator invokes the target function object * stored by @c this. */ _Res operator()(_ArgTypes... __args) const; #if __cpp_rtti // [3.7.2.5] function target access /** * @brief Determine the type of the target of this function object * wrapper. * * @returns the type identifier of the target function object, or * @c typeid(void) if @c !(bool)*this. * * This function will not throw an %exception. */ const type_info& target_type() const; /** * @brief Access the stored target function object. * * @return Returns a pointer to the stored target function object, * if @c typeid(Functor).equals(target_type()); otherwise, a NULL * pointer. * * This function will not throw an %exception. */ template _Functor* target(); /// @overload template const _Functor* target() const; #endif private: // [3.7.2.6] undefined operators template void operator==(const function<_Function>&) const; template void operator!=(const function<_Function>&) const; typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...); _Invoker_type _M_invoker; }; template function<_Res(_ArgTypes...)>:: function(const function& __x) : _Function_base() { if (static_cast(__x)) { __x._M_manager(_M_functor, __x._M_functor, __clone_functor); _M_invoker = __x._M_invoker; _M_manager = __x._M_manager; } } template template function<_Res(_ArgTypes...)>:: function(_Functor __f, typename __gnu_cxx::__enable_if< !is_integral<_Functor>::value, _Useless>::__type) : _Function_base() { typedef _Function_handler<_Signature_type, _Functor> _My_handler; if (_My_handler::_M_not_empty_function(__f)) { _My_handler::_M_init_functor(_M_functor, __f); _M_invoker = &_My_handler::_M_invoke; _M_manager = &_My_handler::_M_manager; } } template _Res function<_Res(_ArgTypes...)>:: operator()(_ArgTypes... __args) const { if (_M_empty()) _GLIBCXX_THROW_OR_ABORT(bad_function_call()); return _M_invoker(_M_functor, __args...); } #if __cpp_rtti template const type_info& function<_Res(_ArgTypes...)>:: target_type() const { if (_M_manager) { _Any_data __typeinfo_result; _M_manager(__typeinfo_result, _M_functor, __get_type_info); return *__typeinfo_result._M_access(); } else return typeid(void); } template template _Functor* function<_Res(_ArgTypes...)>:: target() { if (typeid(_Functor) == target_type() && _M_manager) { _Any_data __ptr; if (_M_manager(__ptr, _M_functor, __get_functor_ptr) && !is_const<_Functor>::value) return 0; else return __ptr._M_access<_Functor*>(); } else return 0; } template template const _Functor* function<_Res(_ArgTypes...)>:: target() const { if (typeid(_Functor) == target_type() && _M_manager) { _Any_data __ptr; _M_manager(__ptr, _M_functor, __get_functor_ptr); return __ptr._M_access(); } else return 0; } #endif // [3.7.2.7] null pointer comparisons /** * @brief Compares a polymorphic function object wrapper against 0 * (the NULL pointer). * @returns @c true if the wrapper has no target, @c false otherwise * * This function will not throw an %exception. */ template inline bool operator==(const function<_Signature>& __f, _M_clear_type*) { return !static_cast(__f); } /// @overload template inline bool operator==(_M_clear_type*, const function<_Signature>& __f) { return !static_cast(__f); } /** * @brief Compares a polymorphic function object wrapper against 0 * (the NULL pointer). * @returns @c false if the wrapper has no target, @c true otherwise * * This function will not throw an %exception. */ template inline bool operator!=(const function<_Signature>& __f, _M_clear_type*) { return static_cast(__f); } /// @overload template inline bool operator!=(_M_clear_type*, const function<_Signature>& __f) { return static_cast(__f); } // [3.7.2.8] specialized algorithms /** * @brief Swap the targets of two polymorphic function object wrappers. * * This function will not throw an %exception. */ template inline void swap(function<_Signature>& __x, function<_Signature>& __y) { __x.swap(__y); } } #if __cplusplus >= 201103L template struct is_placeholder; template struct is_placeholder> : integral_constant { }; template struct is_placeholder> : integral_constant { }; template struct is_bind_expression; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; template struct is_bind_expression> : true_type { }; #endif // C++11 _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_FUNCTIONAL c++/8/tr1/unordered_map000064400000003046152640040200010534 0ustar00// TR1 unordered_map -*- C++ -*- // Copyright (C) 2005-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/unordered_map * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_UNORDERED_MAP #define _GLIBCXX_TR1_UNORDERED_MAP 1 #pragma GCC system_header #include #include #include #include // equal_to, _Identity, _Select1st #include #include #include #include #include #endif // _GLIBCXX_TR1_UNORDERED_MAP c++/8/tr1/unordered_map.h000064400000023750152640040200010766 0ustar00// TR1 unordered_map implementation -*- C++ -*- // Copyright (C) 2010-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/unordered_map.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/unordered_map} */ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { // NB: When we get typedef templates these class definitions // will be unnecessary. template, class _Pred = std::equal_to<_Key>, class _Alloc = std::allocator >, bool __cache_hash_code = false> class __unordered_map : public _Hashtable<_Key, std::pair, _Alloc, std::_Select1st >, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, false, true> { typedef _Hashtable<_Key, std::pair, _Alloc, std::_Select1st >, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, false, true> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit __unordered_map(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Select1st >(), __a) { } template __unordered_map(_InputIterator __f, _InputIterator __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Select1st >(), __a) { } }; template, class _Pred = std::equal_to<_Key>, class _Alloc = std::allocator >, bool __cache_hash_code = false> class __unordered_multimap : public _Hashtable<_Key, std::pair, _Alloc, std::_Select1st >, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, false, false> { typedef _Hashtable<_Key, std::pair, _Alloc, std::_Select1st >, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, false, false> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit __unordered_multimap(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Select1st >(), __a) { } template __unordered_multimap(_InputIterator __f, _InputIterator __l, typename _Base::size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Select1st >(), __a) { } }; template inline void swap(__unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc, __cache_hash_code>& __x, __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc, __cache_hash_code>& __y) { __x.swap(__y); } template inline void swap(__unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc, __cache_hash_code>& __x, __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc, __cache_hash_code>& __y) { __x.swap(__y); } /** * @brief A standard container composed of unique keys (containing * at most one of each key value) that associates values of another type * with the keys. * * @ingroup unordered_associative_containers * * Meets the requirements of a container, and * unordered associative container * * @param Key Type of key objects. * @param Tp Type of mapped objects. * @param Hash Hashing function object type, defaults to hash. * @param Pred Predicate function object type, defaults to equal_to. * @param Alloc Allocator type, defaults to allocator. * * The resulting value type of the container is std::pair. */ template, class _Pred = std::equal_to<_Key>, class _Alloc = std::allocator > > class unordered_map : public __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> { typedef __unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> _Base; public: typedef typename _Base::value_type value_type; typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit unordered_map(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_map(_InputIterator __f, _InputIterator __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } }; /** * @brief A standard container composed of equivalent keys * (possibly containing multiple of each key value) that associates * values of another type with the keys. * * @ingroup unordered_associative_containers * * Meets the requirements of a container, and * unordered associative container * * @param Key Type of key objects. * @param Tp Type of mapped objects. * @param Hash Hashing function object type, defaults to hash. * @param Pred Predicate function object type, defaults to equal_to. * @param Alloc Allocator type, defaults to allocator. * * The resulting value type of the container is std::pair. */ template, class _Pred = std::equal_to<_Key>, class _Alloc = std::allocator > > class unordered_multimap : public __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> { typedef __unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> _Base; public: typedef typename _Base::value_type value_type; typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit unordered_multimap(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_multimap(_InputIterator __f, _InputIterator __l, typename _Base::size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } }; template inline void swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { __x.swap(__y); } template inline void swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { __x.swap(__y); } } _GLIBCXX_END_NAMESPACE_VERSION } c++/8/tr1/poly_hermite.tcc000064400000007525152640040200011166 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/poly_hermite.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // Ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, Section 22 pp. 773-802 #ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC #define _GLIBCXX_TR1_POLY_HERMITE_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief This routine returns the Hermite polynomial * of order n: \f$ H_n(x) \f$ by recursion on n. * * The Hermite polynomial is defined by: * @f[ * H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2} * @f] * * @param __n The order of the Hermite polynomial. * @param __x The argument of the Hermite polynomial. * @return The value of the Hermite polynomial of order n * and argument x. */ template _Tp __poly_hermite_recursion(unsigned int __n, _Tp __x) { // Compute H_0. _Tp __H_0 = 1; if (__n == 0) return __H_0; // Compute H_1. _Tp __H_1 = 2 * __x; if (__n == 1) return __H_1; // Compute H_n. _Tp __H_n, __H_nm1, __H_nm2; unsigned int __i; for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) { __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); __H_nm2 = __H_nm1; __H_nm1 = __H_n; } return __H_n; } /** * @brief This routine returns the Hermite polynomial * of order n: \f$ H_n(x) \f$. * * The Hermite polynomial is defined by: * @f[ * H_n(x) = (-1)^n e^{x^2} \frac{d^n}{dx^n} e^{-x^2} * @f] * * @param __n The order of the Hermite polynomial. * @param __x The argument of the Hermite polynomial. * @return The value of the Hermite polynomial of order n * and argument x. */ template inline _Tp __poly_hermite(unsigned int __n, _Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __poly_hermite_recursion(__n, __x); } } // namespace __detail #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_POLY_HERMITE_TCC c++/8/tr1/ccomplex000064400000002347152640040200007525 0ustar00// TR1 ccomplex -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/ccomplex * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CCOMPLEX #define _GLIBCXX_TR1_CCOMPLEX 1 #include #endif // _GLIBCXX_TR1_CCOMPLEX c++/8/tr1/beta_function.tcc000064400000013553152640040200011304 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/beta_function.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 6, pp. 253-266 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 213-216 // (4) Gamma, Exploring Euler's Constant, Julian Havil, // Princeton, 2003. #ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC #define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Return the beta function: \f$B(x,y)\f$. * * The beta function is defined by * @f[ * B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)} * @f] * * @param __x The first argument of the beta function. * @param __y The second argument of the beta function. * @return The beta function. */ template _Tp __beta_gamma(_Tp __x, _Tp __y) { _Tp __bet; #if _GLIBCXX_USE_C99_MATH_TR1 if (__x > __y) { __bet = _GLIBCXX_MATH_NS::tgamma(__x) / _GLIBCXX_MATH_NS::tgamma(__x + __y); __bet *= _GLIBCXX_MATH_NS::tgamma(__y); } else { __bet = _GLIBCXX_MATH_NS::tgamma(__y) / _GLIBCXX_MATH_NS::tgamma(__x + __y); __bet *= _GLIBCXX_MATH_NS::tgamma(__x); } #else if (__x > __y) { __bet = __gamma(__x) / __gamma(__x + __y); __bet *= __gamma(__y); } else { __bet = __gamma(__y) / __gamma(__x + __y); __bet *= __gamma(__x); } #endif return __bet; } /** * @brief Return the beta function \f$B(x,y)\f$ using * the log gamma functions. * * The beta function is defined by * @f[ * B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)} * @f] * * @param __x The first argument of the beta function. * @param __y The second argument of the beta function. * @return The beta function. */ template _Tp __beta_lgamma(_Tp __x, _Tp __y) { #if _GLIBCXX_USE_C99_MATH_TR1 _Tp __bet = _GLIBCXX_MATH_NS::lgamma(__x) + _GLIBCXX_MATH_NS::lgamma(__y) - _GLIBCXX_MATH_NS::lgamma(__x + __y); #else _Tp __bet = __log_gamma(__x) + __log_gamma(__y) - __log_gamma(__x + __y); #endif __bet = std::exp(__bet); return __bet; } /** * @brief Return the beta function \f$B(x,y)\f$ using * the product form. * * The beta function is defined by * @f[ * B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)} * @f] * * @param __x The first argument of the beta function. * @param __y The second argument of the beta function. * @return The beta function. */ template _Tp __beta_product(_Tp __x, _Tp __y) { _Tp __bet = (__x + __y) / (__x * __y); unsigned int __max_iter = 1000000; for (unsigned int __k = 1; __k < __max_iter; ++__k) { _Tp __term = (_Tp(1) + (__x + __y) / __k) / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); __bet *= __term; } return __bet; } /** * @brief Return the beta function \f$ B(x,y) \f$. * * The beta function is defined by * @f[ * B(x,y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)} * @f] * * @param __x The first argument of the beta function. * @param __y The second argument of the beta function. * @return The beta function. */ template inline _Tp __beta(_Tp __x, _Tp __y) { if (__isnan(__x) || __isnan(__y)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __beta_lgamma(__x, __y); } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_BETA_FUNCTION_TCC c++/8/tr1/stdio.h000064400000002271152640040200007257 0ustar00// TR1 stdio.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/stdio.h * This is a TR1 C++ Library header. */ #ifndef _TR1_STDIO_H #define _TR1_STDIO_H 1 #include #endif c++/8/tr1/random.tcc000064400000151247152640040200007747 0ustar00// random number generation (out of line) -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/random.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/random} */ #ifndef _GLIBCXX_TR1_RANDOM_TCC #define _GLIBCXX_TR1_RANDOM_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /* * (Further) implementation-space details. */ namespace __detail { // General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid // integer overflow. // // Because a and c are compile-time integral constants the compiler kindly // elides any unreachable paths. // // Preconditions: a > 0, m > 0. // template struct _Mod { static _Tp __calc(_Tp __x) { if (__a == 1) __x %= __m; else { static const _Tp __q = __m / __a; static const _Tp __r = __m % __a; _Tp __t1 = __a * (__x % __q); _Tp __t2 = __r * (__x / __q); if (__t1 >= __t2) __x = __t1 - __t2; else __x = __m - __t2 + __t1; } if (__c != 0) { const _Tp __d = __m - __x; if (__d > __c) __x += __c; else __x = __c - __d; } return __x; } }; // Special case for m == 0 -- use unsigned integer overflow as modulo // operator. template struct _Mod<_Tp, __a, __c, __m, true> { static _Tp __calc(_Tp __x) { return __a * __x + __c; } }; } // namespace __detail template const _UIntType linear_congruential<_UIntType, __a, __c, __m>::multiplier; template const _UIntType linear_congruential<_UIntType, __a, __c, __m>::increment; template const _UIntType linear_congruential<_UIntType, __a, __c, __m>::modulus; /** * Seeds the LCR with integral value @p __x0, adjusted so that the * ring identity is never a member of the convergence set. */ template void linear_congruential<_UIntType, __a, __c, __m>:: seed(unsigned long __x0) { if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0)) _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1); else _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0); } /** * Seeds the LCR engine with a value generated by @p __g. */ template template void linear_congruential<_UIntType, __a, __c, __m>:: seed(_Gen& __g, false_type) { _UIntType __x0 = __g(); if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0)) _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1); else _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0); } /** * Gets the next generated value in sequence. */ template typename linear_congruential<_UIntType, __a, __c, __m>::result_type linear_congruential<_UIntType, __a, __c, __m>:: operator()() { _M_x = __detail::__mod<_UIntType, __a, __c, __m>(_M_x); return _M_x; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const linear_congruential<_UIntType, __a, __c, __m>& __lcr) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__os.widen(' ')); __os << __lcr._M_x; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, linear_congruential<_UIntType, __a, __c, __m>& __lcr) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec); __is >> __lcr._M_x; __is.flags(__flags); return __is; } template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::word_size; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::state_size; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::shift_size; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::mask_bits; template const _UIntType mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::parameter_a; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_u; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_s; template const _UIntType mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_b; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_t; template const _UIntType mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_c; template const int mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::output_l; template void mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>:: seed(unsigned long __value) { _M_x[0] = __detail::__mod<_UIntType, 1, 0, __detail::_Shift<_UIntType, __w>::__value>(__value); for (int __i = 1; __i < state_size; ++__i) { _UIntType __x = _M_x[__i - 1]; __x ^= __x >> (__w - 2); __x *= 1812433253ul; __x += __i; _M_x[__i] = __detail::__mod<_UIntType, 1, 0, __detail::_Shift<_UIntType, __w>::__value>(__x); } _M_p = state_size; } template template void mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>:: seed(_Gen& __gen, false_type) { for (int __i = 0; __i < state_size; ++__i) _M_x[__i] = __detail::__mod<_UIntType, 1, 0, __detail::_Shift<_UIntType, __w>::__value>(__gen()); _M_p = state_size; } template typename mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>::result_type mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>:: operator()() { // Reload the vector - cost is O(n) amortized over n calls. if (_M_p >= state_size) { const _UIntType __upper_mask = (~_UIntType()) << __r; const _UIntType __lower_mask = ~__upper_mask; for (int __k = 0; __k < (__n - __m); ++__k) { _UIntType __y = ((_M_x[__k] & __upper_mask) | (_M_x[__k + 1] & __lower_mask)); _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); } for (int __k = (__n - __m); __k < (__n - 1); ++__k) { _UIntType __y = ((_M_x[__k] & __upper_mask) | (_M_x[__k + 1] & __lower_mask)); _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); } _UIntType __y = ((_M_x[__n - 1] & __upper_mask) | (_M_x[0] & __lower_mask)); _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); _M_p = 0; } // Calculate o(x(i)). result_type __z = _M_x[_M_p++]; __z ^= (__z >> __u); __z ^= (__z << __s) & __b; __z ^= (__z << __t) & __c; __z ^= (__z >> __l); return __z; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); for (int __i = 0; __i < __n - 1; ++__i) __os << __x._M_x[__i] << __space; __os << __x._M_x[__n - 1]; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, mersenne_twister<_UIntType, __w, __n, __m, __r, __a, __u, __s, __b, __t, __c, __l>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); for (int __i = 0; __i < __n; ++__i) __is >> __x._M_x[__i]; __is.flags(__flags); return __is; } template const _IntType subtract_with_carry<_IntType, __m, __s, __r>::modulus; template const int subtract_with_carry<_IntType, __m, __s, __r>::long_lag; template const int subtract_with_carry<_IntType, __m, __s, __r>::short_lag; template void subtract_with_carry<_IntType, __m, __s, __r>:: seed(unsigned long __value) { if (__value == 0) __value = 19780503; std::tr1::linear_congruential __lcg(__value); for (int __i = 0; __i < long_lag; ++__i) _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__lcg()); _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; _M_p = 0; } template template void subtract_with_carry<_IntType, __m, __s, __r>:: seed(_Gen& __gen, false_type) { const int __n = (std::numeric_limits<_UIntType>::digits + 31) / 32; for (int __i = 0; __i < long_lag; ++__i) { _UIntType __tmp = 0; _UIntType __factor = 1; for (int __j = 0; __j < __n; ++__j) { __tmp += __detail::__mod<__detail::_UInt32Type, 1, 0, 0> (__gen()) * __factor; __factor *= __detail::_Shift<_UIntType, 32>::__value; } _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__tmp); } _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; _M_p = 0; } template typename subtract_with_carry<_IntType, __m, __s, __r>::result_type subtract_with_carry<_IntType, __m, __s, __r>:: operator()() { // Derive short lag index from current index. int __ps = _M_p - short_lag; if (__ps < 0) __ps += long_lag; // Calculate new x(i) without overflow or division. // NB: Thanks to the requirements for _IntType, _M_x[_M_p] + _M_carry // cannot overflow. _UIntType __xi; if (_M_x[__ps] >= _M_x[_M_p] + _M_carry) { __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry; _M_carry = 0; } else { __xi = modulus - _M_x[_M_p] - _M_carry + _M_x[__ps]; _M_carry = 1; } _M_x[_M_p] = __xi; // Adjust current index to loop around in ring buffer. if (++_M_p >= long_lag) _M_p = 0; return __xi; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry<_IntType, __m, __s, __r>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); for (int __i = 0; __i < __r; ++__i) __os << __x._M_x[__i] << __space; __os << __x._M_carry; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, subtract_with_carry<_IntType, __m, __s, __r>& __x) { typedef std::basic_ostream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); for (int __i = 0; __i < __r; ++__i) __is >> __x._M_x[__i]; __is >> __x._M_carry; __is.flags(__flags); return __is; } template const int subtract_with_carry_01<_RealType, __w, __s, __r>::word_size; template const int subtract_with_carry_01<_RealType, __w, __s, __r>::long_lag; template const int subtract_with_carry_01<_RealType, __w, __s, __r>::short_lag; template void subtract_with_carry_01<_RealType, __w, __s, __r>:: _M_initialize_npows() { for (int __j = 0; __j < __n; ++__j) #if _GLIBCXX_USE_C99_MATH_TR1 _M_npows[__j] = std::tr1::ldexp(_RealType(1), -__w + __j * 32); #else _M_npows[__j] = std::pow(_RealType(2), -__w + __j * 32); #endif } template void subtract_with_carry_01<_RealType, __w, __s, __r>:: seed(unsigned long __value) { if (__value == 0) __value = 19780503; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 512. Seeding subtract_with_carry_01 from a single unsigned long. std::tr1::linear_congruential __lcg(__value); this->seed(__lcg); } template template void subtract_with_carry_01<_RealType, __w, __s, __r>:: seed(_Gen& __gen, false_type) { for (int __i = 0; __i < long_lag; ++__i) { for (int __j = 0; __j < __n - 1; ++__j) _M_x[__i][__j] = __detail::__mod<_UInt32Type, 1, 0, 0>(__gen()); _M_x[__i][__n - 1] = __detail::__mod<_UInt32Type, 1, 0, __detail::_Shift<_UInt32Type, __w % 32>::__value>(__gen()); } _M_carry = 1; for (int __j = 0; __j < __n; ++__j) if (_M_x[long_lag - 1][__j] != 0) { _M_carry = 0; break; } _M_p = 0; } template typename subtract_with_carry_01<_RealType, __w, __s, __r>::result_type subtract_with_carry_01<_RealType, __w, __s, __r>:: operator()() { // Derive short lag index from current index. int __ps = _M_p - short_lag; if (__ps < 0) __ps += long_lag; _UInt32Type __new_carry; for (int __j = 0; __j < __n - 1; ++__j) { if (_M_x[__ps][__j] > _M_x[_M_p][__j] || (_M_x[__ps][__j] == _M_x[_M_p][__j] && _M_carry == 0)) __new_carry = 0; else __new_carry = 1; _M_x[_M_p][__j] = _M_x[__ps][__j] - _M_x[_M_p][__j] - _M_carry; _M_carry = __new_carry; } if (_M_x[__ps][__n - 1] > _M_x[_M_p][__n - 1] || (_M_x[__ps][__n - 1] == _M_x[_M_p][__n - 1] && _M_carry == 0)) __new_carry = 0; else __new_carry = 1; _M_x[_M_p][__n - 1] = __detail::__mod<_UInt32Type, 1, 0, __detail::_Shift<_UInt32Type, __w % 32>::__value> (_M_x[__ps][__n - 1] - _M_x[_M_p][__n - 1] - _M_carry); _M_carry = __new_carry; result_type __ret = 0.0; for (int __j = 0; __j < __n; ++__j) __ret += _M_x[_M_p][__j] * _M_npows[__j]; // Adjust current index to loop around in ring buffer. if (++_M_p >= long_lag) _M_p = 0; return __ret; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_01<_RealType, __w, __s, __r>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); for (int __i = 0; __i < __r; ++__i) for (int __j = 0; __j < __x.__n; ++__j) __os << __x._M_x[__i][__j] << __space; __os << __x._M_carry; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, subtract_with_carry_01<_RealType, __w, __s, __r>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); for (int __i = 0; __i < __r; ++__i) for (int __j = 0; __j < __x.__n; ++__j) __is >> __x._M_x[__i][__j]; __is >> __x._M_carry; __is.flags(__flags); return __is; } template const int discard_block<_UniformRandomNumberGenerator, __p, __r>::block_size; template const int discard_block<_UniformRandomNumberGenerator, __p, __r>::used_block; template typename discard_block<_UniformRandomNumberGenerator, __p, __r>::result_type discard_block<_UniformRandomNumberGenerator, __p, __r>:: operator()() { if (_M_n >= used_block) { while (_M_n < block_size) { _M_b(); ++_M_n; } _M_n = 0; } ++_M_n; return _M_b(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const discard_block<_UniformRandomNumberGenerator, __p, __r>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); __os << __x._M_b << __space << __x._M_n; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, discard_block<_UniformRandomNumberGenerator, __p, __r>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_b >> __x._M_n; __is.flags(__flags); return __is; } template const int xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>::shift1; template const int xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>::shift2; template void xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>:: _M_initialize_max() { const int __w = std::numeric_limits::digits; const result_type __m1 = std::min(result_type(_M_b1.max() - _M_b1.min()), __detail::_Shift::__value - 1); const result_type __m2 = std::min(result_type(_M_b2.max() - _M_b2.min()), __detail::_Shift::__value - 1); // NB: In TR1 s1 is not required to be >= s2. if (__s1 < __s2) _M_max = _M_initialize_max_aux(__m2, __m1, __s2 - __s1) << __s1; else _M_max = _M_initialize_max_aux(__m1, __m2, __s1 - __s2) << __s2; } template typename xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>::result_type xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>:: _M_initialize_max_aux(result_type __a, result_type __b, int __d) { const result_type __two2d = result_type(1) << __d; const result_type __c = __a * __two2d; if (__a == 0 || __b < __two2d) return __c + __b; const result_type __t = std::max(__c, __b); const result_type __u = std::min(__c, __b); result_type __ub = __u; result_type __p; for (__p = 0; __ub != 1; __ub >>= 1) ++__p; const result_type __two2p = result_type(1) << __p; const result_type __k = __t / __two2p; if (__k & 1) return (__k + 1) * __two2p - 1; if (__c >= __b) return (__k + 1) * __two2p + _M_initialize_max_aux((__t % __two2p) / __two2d, __u % __two2p, __d); else return (__k + 1) * __two2p + _M_initialize_max_aux((__u % __two2p) / __two2d, __t % __two2p, __d); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); __os << __x.base1() << __space << __x.base2(); __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, xor_combine<_UniformRandomNumberGenerator1, __s1, _UniformRandomNumberGenerator2, __s2>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); __is >> __x._M_b1 >> __x._M_b2; __is.flags(__flags); return __is; } template template typename uniform_int<_IntType>::result_type uniform_int<_IntType>:: _M_call(_UniformRandomNumberGenerator& __urng, result_type __min, result_type __max, true_type) { // XXX Must be fixed to work well for *arbitrary* __urng.max(), // __urng.min(), __max, __min. Currently works fine only in the // most common case __urng.max() - __urng.min() >= __max - __min, // with __urng.max() > __urng.min() >= 0. typedef typename __gnu_cxx::__add_unsigned::__type __urntype; typedef typename __gnu_cxx::__add_unsigned::__type __utype; typedef typename __gnu_cxx::__conditional_type<(sizeof(__urntype) > sizeof(__utype)), __urntype, __utype>::__type __uctype; result_type __ret; const __urntype __urnmin = __urng.min(); const __urntype __urnmax = __urng.max(); const __urntype __urnrange = __urnmax - __urnmin; const __uctype __urange = __max - __min; const __uctype __udenom = (__urnrange <= __urange ? 1 : __urnrange / (__urange + 1)); do __ret = (__urntype(__urng()) - __urnmin) / __udenom; while (__ret > __max - __min); return __ret + __min; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_int<_IntType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os << __x.min() << __space << __x.max(); __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_int<_IntType>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_min >> __x._M_max; __is.flags(__flags); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(__gnu_cxx::__numeric_traits::__max_digits10); __os << __x.p(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template template typename geometric_distribution<_IntType, _RealType>::result_type geometric_distribution<_IntType, _RealType>:: operator()(_UniformRandomNumberGenerator& __urng) { // About the epsilon thing see this thread: // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html const _RealType __naf = (1 - std::numeric_limits<_RealType>::epsilon()) / 2; // The largest _RealType convertible to _IntType. const _RealType __thr = std::numeric_limits<_IntType>::max() + __naf; _RealType __cand; do __cand = std::ceil(std::log(__urng()) / _M_log_p); while (__cand >= __thr); return result_type(__cand + __naf); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const geometric_distribution<_IntType, _RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.p(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template void poisson_distribution<_IntType, _RealType>:: _M_initialize() { #if _GLIBCXX_USE_C99_MATH_TR1 if (_M_mean >= 12) { const _RealType __m = std::floor(_M_mean); _M_lm_thr = std::log(_M_mean); _M_lfm = std::tr1::lgamma(__m + 1); _M_sm = std::sqrt(__m); const _RealType __pi_4 = 0.7853981633974483096156608458198757L; const _RealType __dx = std::sqrt(2 * __m * std::log(32 * __m / __pi_4)); _M_d = std::tr1::round(std::max(_RealType(6), std::min(__m, __dx))); const _RealType __cx = 2 * __m + _M_d; _M_scx = std::sqrt(__cx / 2); _M_1cx = 1 / __cx; _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx); _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2)) / _M_d; } else #endif _M_lm_thr = std::exp(-_M_mean); } /** * A rejection algorithm when mean >= 12 and a simple method based * upon the multiplication of uniform random variates otherwise. * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1 * is defined. * * Reference: * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!). */ template template typename poisson_distribution<_IntType, _RealType>::result_type poisson_distribution<_IntType, _RealType>:: operator()(_UniformRandomNumberGenerator& __urng) { #if _GLIBCXX_USE_C99_MATH_TR1 if (_M_mean >= 12) { _RealType __x; // See comments above... const _RealType __naf = (1 - std::numeric_limits<_RealType>::epsilon()) / 2; const _RealType __thr = std::numeric_limits<_IntType>::max() + __naf; const _RealType __m = std::floor(_M_mean); // sqrt(pi / 2) const _RealType __spi_2 = 1.2533141373155002512078826424055226L; const _RealType __c1 = _M_sm * __spi_2; const _RealType __c2 = _M_c2b + __c1; const _RealType __c3 = __c2 + 1; const _RealType __c4 = __c3 + 1; // e^(1 / 78) const _RealType __e178 = 1.0129030479320018583185514777512983L; const _RealType __c5 = __c4 + __e178; const _RealType __c = _M_cb + __c5; const _RealType __2cx = 2 * (2 * __m + _M_d); bool __reject = true; do { const _RealType __u = __c * __urng(); const _RealType __e = -std::log(__urng()); _RealType __w = 0.0; if (__u <= __c1) { const _RealType __n = _M_nd(__urng); const _RealType __y = -std::abs(__n) * _M_sm - 1; __x = std::floor(__y); __w = -__n * __n / 2; if (__x < -__m) continue; } else if (__u <= __c2) { const _RealType __n = _M_nd(__urng); const _RealType __y = 1 + std::abs(__n) * _M_scx; __x = std::ceil(__y); __w = __y * (2 - __y) * _M_1cx; if (__x > _M_d) continue; } else if (__u <= __c3) // NB: This case not in the book, nor in the Errata, // but should be ok... __x = -1; else if (__u <= __c4) __x = 0; else if (__u <= __c5) __x = 1; else { const _RealType __v = -std::log(__urng()); const _RealType __y = _M_d + __v * __2cx / _M_d; __x = std::ceil(__y); __w = -_M_d * _M_1cx * (1 + __y / 2); } __reject = (__w - __e - __x * _M_lm_thr > _M_lfm - std::tr1::lgamma(__x + __m + 1)); __reject |= __x + __m >= __thr; } while (__reject); return result_type(__x + __m + __naf); } else #endif { _IntType __x = 0; _RealType __prod = 1.0; do { __prod *= __urng(); __x += 1; } while (__prod > _M_lm_thr); return __x - 1; } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const poisson_distribution<_IntType, _RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.mean() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, poisson_distribution<_IntType, _RealType>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); __is >> __x._M_mean >> __x._M_nd; __x._M_initialize(); __is.flags(__flags); return __is; } template void binomial_distribution<_IntType, _RealType>:: _M_initialize() { const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p; _M_easy = true; #if _GLIBCXX_USE_C99_MATH_TR1 if (_M_t * __p12 >= 8) { _M_easy = false; const _RealType __np = std::floor(_M_t * __p12); const _RealType __pa = __np / _M_t; const _RealType __1p = 1 - __pa; const _RealType __pi_4 = 0.7853981633974483096156608458198757L; const _RealType __d1x = std::sqrt(__np * __1p * std::log(32 * __np / (81 * __pi_4 * __1p))); _M_d1 = std::tr1::round(std::max(_RealType(1), __d1x)); const _RealType __d2x = std::sqrt(__np * __1p * std::log(32 * _M_t * __1p / (__pi_4 * __pa))); _M_d2 = std::tr1::round(std::max(_RealType(1), __d2x)); // sqrt(pi / 2) const _RealType __spi_2 = 1.2533141373155002512078826424055226L; _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np)); _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p)); _M_c = 2 * _M_d1 / __np; _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2; const _RealType __a12 = _M_a1 + _M_s2 * __spi_2; const _RealType __s1s = _M_s1 * _M_s1; _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p)) * 2 * __s1s / _M_d1 * std::exp(-_M_d1 * _M_d1 / (2 * __s1s))); const _RealType __s2s = _M_s2 * _M_s2; _M_s = (_M_a123 + 2 * __s2s / _M_d2 * std::exp(-_M_d2 * _M_d2 / (2 * __s2s))); _M_lf = (std::tr1::lgamma(__np + 1) + std::tr1::lgamma(_M_t - __np + 1)); _M_lp1p = std::log(__pa / __1p); _M_q = -std::log(1 - (__p12 - __pa) / __1p); } else #endif _M_q = -std::log(1 - __p12); } template template typename binomial_distribution<_IntType, _RealType>::result_type binomial_distribution<_IntType, _RealType>:: _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t) { _IntType __x = 0; _RealType __sum = 0; do { const _RealType __e = -std::log(__urng()); __sum += __e / (__t - __x); __x += 1; } while (__sum <= _M_q); return __x - 1; } /** * A rejection algorithm when t * p >= 8 and a simple waiting time * method - the second in the referenced book - otherwise. * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1 * is defined. * * Reference: * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, * New York, 1986, Ch. X, Sect. 4 (+ Errata!). */ template template typename binomial_distribution<_IntType, _RealType>::result_type binomial_distribution<_IntType, _RealType>:: operator()(_UniformRandomNumberGenerator& __urng) { result_type __ret; const _RealType __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p; #if _GLIBCXX_USE_C99_MATH_TR1 if (!_M_easy) { _RealType __x; // See comments above... const _RealType __naf = (1 - std::numeric_limits<_RealType>::epsilon()) / 2; const _RealType __thr = std::numeric_limits<_IntType>::max() + __naf; const _RealType __np = std::floor(_M_t * __p12); const _RealType __pa = __np / _M_t; // sqrt(pi / 2) const _RealType __spi_2 = 1.2533141373155002512078826424055226L; const _RealType __a1 = _M_a1; const _RealType __a12 = __a1 + _M_s2 * __spi_2; const _RealType __a123 = _M_a123; const _RealType __s1s = _M_s1 * _M_s1; const _RealType __s2s = _M_s2 * _M_s2; bool __reject; do { const _RealType __u = _M_s * __urng(); _RealType __v; if (__u <= __a1) { const _RealType __n = _M_nd(__urng); const _RealType __y = _M_s1 * std::abs(__n); __reject = __y >= _M_d1; if (!__reject) { const _RealType __e = -std::log(__urng()); __x = std::floor(__y); __v = -__e - __n * __n / 2 + _M_c; } } else if (__u <= __a12) { const _RealType __n = _M_nd(__urng); const _RealType __y = _M_s2 * std::abs(__n); __reject = __y >= _M_d2; if (!__reject) { const _RealType __e = -std::log(__urng()); __x = std::floor(-__y); __v = -__e - __n * __n / 2; } } else if (__u <= __a123) { const _RealType __e1 = -std::log(__urng()); const _RealType __e2 = -std::log(__urng()); const _RealType __y = _M_d1 + 2 * __s1s * __e1 / _M_d1; __x = std::floor(__y); __v = (-__e2 + _M_d1 * (1 / (_M_t - __np) -__y / (2 * __s1s))); __reject = false; } else { const _RealType __e1 = -std::log(__urng()); const _RealType __e2 = -std::log(__urng()); const _RealType __y = _M_d2 + 2 * __s2s * __e1 / _M_d2; __x = std::floor(-__y); __v = -__e2 - _M_d2 * __y / (2 * __s2s); __reject = false; } __reject = __reject || __x < -__np || __x > _M_t - __np; if (!__reject) { const _RealType __lfx = std::tr1::lgamma(__np + __x + 1) + std::tr1::lgamma(_M_t - (__np + __x) + 1); __reject = __v > _M_lf - __lfx + __x * _M_lp1p; } __reject |= __x + __np >= __thr; } while (__reject); __x += __np + __naf; const _IntType __z = _M_waiting(__urng, _M_t - _IntType(__x)); __ret = _IntType(__x) + __z; } else #endif __ret = _M_waiting(__urng, _M_t); if (__p12 != _M_p) __ret = _M_t - __ret; return __ret; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const binomial_distribution<_IntType, _RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.t() << __space << __x.p() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, binomial_distribution<_IntType, _RealType>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_t >> __x._M_p >> __x._M_nd; __x._M_initialize(); __is.flags(__flags); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_real<_RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.min() << __space << __x.max(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_real<_RealType>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); __is >> __x._M_min >> __x._M_max; __is.flags(__flags); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const exponential_distribution<_RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.lambda(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } /** * Polar method due to Marsaglia. * * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, * New York, 1986, Ch. V, Sect. 4.4. */ template template typename normal_distribution<_RealType>::result_type normal_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng) { result_type __ret; if (_M_saved_available) { _M_saved_available = false; __ret = _M_saved; } else { result_type __x, __y, __r2; do { __x = result_type(2.0) * __urng() - 1.0; __y = result_type(2.0) * __urng() - 1.0; __r2 = __x * __x + __y * __y; } while (__r2 > 1.0 || __r2 == 0.0); const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); _M_saved = __x * __mult; _M_saved_available = true; __ret = __y * __mult; } __ret = __ret * _M_sigma + _M_mean; return __ret; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x._M_saved_available << __space << __x.mean() << __space << __x.sigma(); if (__x._M_saved_available) __os << __space << __x._M_saved; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, normal_distribution<_RealType>& __x) { typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_saved_available >> __x._M_mean >> __x._M_sigma; if (__x._M_saved_available) __is >> __x._M_saved; __is.flags(__flags); return __is; } template void gamma_distribution<_RealType>:: _M_initialize() { if (_M_alpha >= 1) _M_l_d = std::sqrt(2 * _M_alpha - 1); else _M_l_d = (std::pow(_M_alpha, _M_alpha / (1 - _M_alpha)) * (1 - _M_alpha)); } /** * Cheng's rejection algorithm GB for alpha >= 1 and a modification * of Vaduva's rejection from Weibull algorithm due to Devroye for * alpha < 1. * * References: * Cheng, R. C. The Generation of Gamma Random Variables with Non-integral * Shape Parameter. Applied Statistics, 26, 71-75, 1977. * * Vaduva, I. Computer Generation of Gamma Gandom Variables by Rejection * and Composition Procedures. Math. Operationsforschung and Statistik, * Series in Statistics, 8, 545-576, 1977. * * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, * New York, 1986, Ch. IX, Sect. 3.4 (+ Errata!). */ template template typename gamma_distribution<_RealType>::result_type gamma_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng) { result_type __x; bool __reject; if (_M_alpha >= 1) { // alpha - log(4) const result_type __b = _M_alpha - result_type(1.3862943611198906188344642429163531L); const result_type __c = _M_alpha + _M_l_d; const result_type __1l = 1 / _M_l_d; // 1 + log(9 / 2) const result_type __k = 2.5040773967762740733732583523868748L; do { const result_type __u = __urng(); const result_type __v = __urng(); const result_type __y = __1l * std::log(__v / (1 - __v)); __x = _M_alpha * std::exp(__y); const result_type __z = __u * __v * __v; const result_type __r = __b + __c * __y - __x; __reject = __r < result_type(4.5) * __z - __k; if (__reject) __reject = __r < std::log(__z); } while (__reject); } else { const result_type __c = 1 / _M_alpha; do { const result_type __z = -std::log(__urng()); const result_type __e = -std::log(__urng()); __x = std::pow(__z, __c); __reject = __z + __e < _M_l_d + __x; } while (__reject); } return __x; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const gamma_distribution<_RealType>& __x) { typedef std::basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(__gnu_cxx::__numeric_traits<_RealType>::__max_digits10); __os << __x.alpha(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } } _GLIBCXX_END_NAMESPACE_VERSION } #endif c++/8/tr1/tgmath.h000064400000002347152640040200007425 0ustar00// TR1 tgmath.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/tgmath.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_TGMATH_H #define _GLIBCXX_TR1_TGMATH_H 1 #include #endif // _GLIBCXX_TR1_TGMATH_H c++/8/tr1/type_traits000064400000045113152640040200010260 0ustar00// TR1 type_traits -*- C++ -*- // Copyright (C) 2004-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/type_traits * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_TYPE_TRAITS #define _GLIBCXX_TR1_TYPE_TRAITS 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @addtogroup metaprogramming * @{ */ struct __sfinae_types { typedef char __one; typedef struct { char __arr[2]; } __two; }; #define _DEFINE_SPEC_0_HELPER \ template<> #define _DEFINE_SPEC_1_HELPER \ template #define _DEFINE_SPEC_2_HELPER \ template #define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \ _DEFINE_SPEC_##_Order##_HELPER \ struct _Trait<_Type> \ : public integral_constant { }; // helper classes [4.3]. /// integral_constant template struct integral_constant { static const _Tp value = __v; typedef _Tp value_type; typedef integral_constant<_Tp, __v> type; }; /// typedef for true_type typedef integral_constant true_type; /// typedef for false_type typedef integral_constant false_type; template const _Tp integral_constant<_Tp, __v>::value; /// remove_cv template struct remove_cv; template struct __is_void_helper : public false_type { }; _DEFINE_SPEC(0, __is_void_helper, void, true) // primary type categories [4.5.1]. /// is_void template struct is_void : public integral_constant::type>::value)> { }; template struct __is_integral_helper : public false_type { }; _DEFINE_SPEC(0, __is_integral_helper, bool, true) _DEFINE_SPEC(0, __is_integral_helper, char, true) _DEFINE_SPEC(0, __is_integral_helper, signed char, true) _DEFINE_SPEC(0, __is_integral_helper, unsigned char, true) #ifdef _GLIBCXX_USE_WCHAR_T _DEFINE_SPEC(0, __is_integral_helper, wchar_t, true) #endif _DEFINE_SPEC(0, __is_integral_helper, short, true) _DEFINE_SPEC(0, __is_integral_helper, unsigned short, true) _DEFINE_SPEC(0, __is_integral_helper, int, true) _DEFINE_SPEC(0, __is_integral_helper, unsigned int, true) _DEFINE_SPEC(0, __is_integral_helper, long, true) _DEFINE_SPEC(0, __is_integral_helper, unsigned long, true) _DEFINE_SPEC(0, __is_integral_helper, long long, true) _DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true) /// is_integral template struct is_integral : public integral_constant::type>::value)> { }; template struct __is_floating_point_helper : public false_type { }; _DEFINE_SPEC(0, __is_floating_point_helper, float, true) _DEFINE_SPEC(0, __is_floating_point_helper, double, true) _DEFINE_SPEC(0, __is_floating_point_helper, long double, true) /// is_floating_point template struct is_floating_point : public integral_constant::type>::value)> { }; /// is_array template struct is_array : public false_type { }; template struct is_array<_Tp[_Size]> : public true_type { }; template struct is_array<_Tp[]> : public true_type { }; template struct __is_pointer_helper : public false_type { }; _DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true) /// is_pointer template struct is_pointer : public integral_constant::type>::value)> { }; /// is_reference template struct is_reference; /// is_function template struct is_function; template struct __is_member_object_pointer_helper : public false_type { }; _DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*, !is_function<_Tp>::value) /// is_member_object_pointer template struct is_member_object_pointer : public integral_constant::type>::value)> { }; template struct __is_member_function_pointer_helper : public false_type { }; _DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*, is_function<_Tp>::value) /// is_member_function_pointer template struct is_member_function_pointer : public integral_constant::type>::value)> { }; /// is_enum template struct is_enum : public integral_constant { }; /// is_union template struct is_union : public integral_constant { }; /// is_class template struct is_class : public integral_constant { }; /// is_function template struct is_function : public false_type { }; template struct is_function<_Res(_ArgTypes...)> : public true_type { }; template struct is_function<_Res(_ArgTypes......)> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const> : public true_type { }; template struct is_function<_Res(_ArgTypes...) volatile> : public true_type { }; template struct is_function<_Res(_ArgTypes......) volatile> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const volatile> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const volatile> : public true_type { }; // composite type traits [4.5.2]. /// is_arithmetic template struct is_arithmetic : public integral_constant::value || is_floating_point<_Tp>::value)> { }; /// is_fundamental template struct is_fundamental : public integral_constant::value || is_void<_Tp>::value)> { }; /// is_object template struct is_object : public integral_constant::value || is_reference<_Tp>::value || is_void<_Tp>::value)> { }; /// is_member_pointer template struct is_member_pointer; /// is_scalar template struct is_scalar : public integral_constant::value || is_enum<_Tp>::value || is_pointer<_Tp>::value || is_member_pointer<_Tp>::value)> { }; /// is_compound template struct is_compound : public integral_constant::value> { }; /// is_member_pointer template struct __is_member_pointer_helper : public false_type { }; _DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true) template struct is_member_pointer : public integral_constant::type>::value)> { }; // type properties [4.5.3]. /// is_const template struct is_const : public false_type { }; template struct is_const<_Tp const> : public true_type { }; /// is_volatile template struct is_volatile : public false_type { }; template struct is_volatile<_Tp volatile> : public true_type { }; /// is_empty template struct is_empty : public integral_constant { }; /// is_polymorphic template struct is_polymorphic : public integral_constant { }; /// is_abstract template struct is_abstract : public integral_constant { }; /// has_virtual_destructor template struct has_virtual_destructor : public integral_constant { }; /// alignment_of template struct alignment_of : public integral_constant { }; /// rank template struct rank : public integral_constant { }; template struct rank<_Tp[_Size]> : public integral_constant::value> { }; template struct rank<_Tp[]> : public integral_constant::value> { }; /// extent template struct extent : public integral_constant { }; template struct extent<_Tp[_Size], _Uint> : public integral_constant::value> { }; template struct extent<_Tp[], _Uint> : public integral_constant::value> { }; // relationships between types [4.6]. /// is_same template struct is_same : public false_type { }; template struct is_same<_Tp, _Tp> : public true_type { }; // const-volatile modifications [4.7.1]. /// remove_const template struct remove_const { typedef _Tp type; }; template struct remove_const<_Tp const> { typedef _Tp type; }; /// remove_volatile template struct remove_volatile { typedef _Tp type; }; template struct remove_volatile<_Tp volatile> { typedef _Tp type; }; /// remove_cv template struct remove_cv { typedef typename remove_const::type>::type type; }; /// add_const template struct add_const { typedef _Tp const type; }; /// add_volatile template struct add_volatile { typedef _Tp volatile type; }; /// add_cv template struct add_cv { typedef typename add_const::type>::type type; }; // array modifications [4.7.3]. /// remove_extent template struct remove_extent { typedef _Tp type; }; template struct remove_extent<_Tp[_Size]> { typedef _Tp type; }; template struct remove_extent<_Tp[]> { typedef _Tp type; }; /// remove_all_extents template struct remove_all_extents { typedef _Tp type; }; template struct remove_all_extents<_Tp[_Size]> { typedef typename remove_all_extents<_Tp>::type type; }; template struct remove_all_extents<_Tp[]> { typedef typename remove_all_extents<_Tp>::type type; }; // pointer modifications [4.7.4]. template struct __remove_pointer_helper { typedef _Tp type; }; template struct __remove_pointer_helper<_Tp, _Up*> { typedef _Up type; }; /// remove_pointer template struct remove_pointer : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> { }; template struct remove_reference; /// add_pointer template struct add_pointer { typedef typename remove_reference<_Tp>::type* type; }; template struct is_reference : public false_type { }; template struct is_reference<_Tp&> : public true_type { }; template struct is_pod : public integral_constant::value> { }; template struct has_trivial_constructor : public integral_constant::value> { }; template struct has_trivial_copy : public integral_constant::value> { }; template struct has_trivial_assign : public integral_constant::value> { }; template struct has_trivial_destructor : public integral_constant::value> { }; template struct has_nothrow_constructor : public integral_constant::value> { }; template struct has_nothrow_copy : public integral_constant::value> { }; template struct has_nothrow_assign : public integral_constant::value> { }; template struct __is_signed_helper : public false_type { }; _DEFINE_SPEC(0, __is_signed_helper, signed char, true) _DEFINE_SPEC(0, __is_signed_helper, short, true) _DEFINE_SPEC(0, __is_signed_helper, int, true) _DEFINE_SPEC(0, __is_signed_helper, long, true) _DEFINE_SPEC(0, __is_signed_helper, long long, true) template struct is_signed : public integral_constant::type>::value)> { }; template struct __is_unsigned_helper : public false_type { }; _DEFINE_SPEC(0, __is_unsigned_helper, unsigned char, true) _DEFINE_SPEC(0, __is_unsigned_helper, unsigned short, true) _DEFINE_SPEC(0, __is_unsigned_helper, unsigned int, true) _DEFINE_SPEC(0, __is_unsigned_helper, unsigned long, true) _DEFINE_SPEC(0, __is_unsigned_helper, unsigned long long, true) template struct is_unsigned : public integral_constant::type>::value)> { }; template struct __is_base_of_helper { typedef typename remove_cv<_Base>::type _NoCv_Base; typedef typename remove_cv<_Derived>::type _NoCv_Derived; static const bool __value = (is_same<_Base, _Derived>::value || (__is_base_of(_Base, _Derived) && !is_same<_NoCv_Base, _NoCv_Derived>::value)); }; template struct is_base_of : public integral_constant::__value> { }; template struct __is_convertible_simple : public __sfinae_types { private: static __one __test(_To); static __two __test(...); static _From __makeFrom(); public: static const bool __value = sizeof(__test(__makeFrom())) == 1; }; template struct add_reference; template struct __is_int_or_cref { typedef typename remove_reference<_Tp>::type __rr_Tp; static const bool __value = (is_integral<_Tp>::value || (is_integral<__rr_Tp>::value && is_const<__rr_Tp>::value && !is_volatile<__rr_Tp>::value)); }; template::value || is_void<_To>::value || is_function<_To>::value || is_array<_To>::value // This special case is here only to avoid warnings. || (is_floating_point::type>::value && __is_int_or_cref<_To>::__value))> struct __is_convertible_helper { // "An imaginary lvalue of type From...". static const bool __value = (__is_convertible_simple::type, _To>::__value); }; template struct __is_convertible_helper<_From, _To, true> { static const bool __value = (is_void<_To>::value || (__is_int_or_cref<_To>::__value && !is_void<_From>::value)); }; template struct is_convertible : public integral_constant::__value> { }; // reference modifications [4.7.2]. template struct remove_reference { typedef _Tp type; }; template struct remove_reference<_Tp&> { typedef _Tp type; }; // NB: Careful with reference to void. template::value || is_reference<_Tp>::value)> struct __add_reference_helper { typedef _Tp& type; }; template struct __add_reference_helper<_Tp, true> { typedef _Tp type; }; template struct add_reference : public __add_reference_helper<_Tp> { }; // other transformations [4.8]. template struct aligned_storage { union type { unsigned char __data[_Len]; struct __attribute__((__aligned__((_Align)))) { } __align; }; }; #undef _DEFINE_SPEC_0_HELPER #undef _DEFINE_SPEC_1_HELPER #undef _DEFINE_SPEC_2_HELPER #undef _DEFINE_SPEC /// @} group metaprogramming } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_TYPE_TRAITS c++/8/tr1/stdbool.h000064400000002303152640040200007577 0ustar00// TR1 stdbool.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/stdbool.h * This is a TR1 C++ Library header. */ #ifndef _TR1_STDBOOL_H #define _TR1_STDBOOL_H 1 #include #endif c++/8/tr1/exp_integral.tcc000064400000037211152640040200011142 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/exp_integral.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // // (1) Handbook of Mathematical Functions, // Ed. by Milton Abramowitz and Irene A. Stegun, // Dover Publications, New-York, Section 5, pp. 228-251. // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 222-225. // #ifndef _GLIBCXX_TR1_EXP_INTEGRAL_TCC #define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1 #include "special_function_util.h" namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { template _Tp __expint_E1(_Tp); /** * @brief Return the exponential integral @f$ E_1(x) @f$ * by series summation. This should be good * for @f$ x < 1 @f$. * * The exponential integral is given by * \f[ * E_1(x) = \int_{1}^{\infty} \frac{e^{-xt}}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_E1_series(_Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __esum = _Tp(0); _Tp __osum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= - __x / __i; if (std::abs(__term) < __eps) break; if (__term >= _Tp(0)) __esum += __term / __i; else __osum += __term / __i; } return - __esum - __osum - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); } /** * @brief Return the exponential integral @f$ E_1(x) @f$ * by asymptotic expansion. * * The exponential integral is given by * \f[ * E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_E1_asymp(_Tp __x) { _Tp __term = _Tp(1); _Tp __esum = _Tp(1); _Tp __osum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { _Tp __prev = __term; __term *= - __i / __x; if (std::abs(__term) > std::abs(__prev)) break; if (__term >= _Tp(0)) __esum += __term; else __osum += __term; } return std::exp(- __x) * (__esum + __osum) / __x; } /** * @brief Return the exponential integral @f$ E_n(x) @f$ * by series summation. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_En_series(unsigned int __n, _Tp __x) { const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const int __nm1 = __n - 1; _Tp __ans = (__nm1 != 0 ? _Tp(1) / __nm1 : -std::log(__x) - __numeric_constants<_Tp>::__gamma_e()); _Tp __fact = _Tp(1); for (int __i = 1; __i <= __max_iter; ++__i) { __fact *= -__x / _Tp(__i); _Tp __del; if ( __i != __nm1 ) __del = -__fact / _Tp(__i - __nm1); else { _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); for (int __ii = 1; __ii <= __nm1; ++__ii) __psi += _Tp(1) / _Tp(__ii); __del = __fact * (__psi - std::log(__x)); } __ans += __del; if (std::abs(__del) < __eps * std::abs(__ans)) return __ans; } std::__throw_runtime_error(__N("Series summation failed " "in __expint_En_series.")); } /** * @brief Return the exponential integral @f$ E_n(x) @f$ * by continued fractions. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_En_cont_frac(unsigned int __n, _Tp __x) { const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = std::numeric_limits<_Tp>::min(); const int __nm1 = __n - 1; _Tp __b = __x + _Tp(__n); _Tp __c = _Tp(1) / __fp_min; _Tp __d = _Tp(1) / __b; _Tp __h = __d; for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) { _Tp __a = -_Tp(__i * (__nm1 + __i)); __b += _Tp(2); __d = _Tp(1) / (__a * __d + __b); __c = __b + __a / __c; const _Tp __del = __c * __d; __h *= __del; if (std::abs(__del - _Tp(1)) < __eps) { const _Tp __ans = __h * std::exp(-__x); return __ans; } } std::__throw_runtime_error(__N("Continued fraction failed " "in __expint_En_cont_frac.")); } /** * @brief Return the exponential integral @f$ E_n(x) @f$ * by recursion. Use upward recursion for @f$ x < n @f$ * and downward recursion (Miller's algorithm) otherwise. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_En_recursion(unsigned int __n, _Tp __x) { _Tp __En; _Tp __E1 = __expint_E1(__x); if (__x < _Tp(__n)) { // Forward recursion is stable only for n < x. __En = __E1; for (unsigned int __j = 2; __j < __n; ++__j) __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); } else { // Backward recursion is stable only for n >= x. __En = _Tp(1); const int __N = __n + 20; // TODO: Check this starting number. _Tp __save = _Tp(0); for (int __j = __N; __j > 0; --__j) { __En = (std::exp(-__x) - __j * __En) / __x; if (__j == __n) __save = __En; } _Tp __norm = __En / __E1; __En /= __norm; } return __En; } /** * @brief Return the exponential integral @f$ Ei(x) @f$ * by series summation. * * The exponential integral is given by * \f[ * Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_Ei_series(_Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= __x / __i; __sum += __term / __i; if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) break; } return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); } /** * @brief Return the exponential integral @f$ Ei(x) @f$ * by asymptotic expansion. * * The exponential integral is given by * \f[ * Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_Ei_asymp(_Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(1); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { _Tp __prev = __term; __term *= __i / __x; if (__term < std::numeric_limits<_Tp>::epsilon()) break; if (__term >= __prev) break; __sum += __term; } return std::exp(__x) * __sum / __x; } /** * @brief Return the exponential integral @f$ Ei(x) @f$. * * The exponential integral is given by * \f[ * Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_Ei(_Tp __x) { if (__x < _Tp(0)) return -__expint_E1(-__x); else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) return __expint_Ei_series(__x); else return __expint_Ei_asymp(__x); } /** * @brief Return the exponential integral @f$ E_1(x) @f$. * * The exponential integral is given by * \f[ * E_1(x) = \int_{1}^\infty \frac{e^{-xt}}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_E1(_Tp __x) { if (__x < _Tp(0)) return -__expint_Ei(-__x); else if (__x < _Tp(1)) return __expint_E1_series(__x); else if (__x < _Tp(100)) // TODO: Find a good asymptotic switch point. return __expint_En_cont_frac(1, __x); else return __expint_E1_asymp(__x); } /** * @brief Return the exponential integral @f$ E_n(x) @f$ * for large argument. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * * This is something of an extension. * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_asymp(unsigned int __n, _Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(1); for (unsigned int __i = 1; __i <= __n; ++__i) { _Tp __prev = __term; __term *= -(__n - __i + 1) / __x; if (std::abs(__term) > std::abs(__prev)) break; __sum += __term; } return std::exp(-__x) * __sum / __x; } /** * @brief Return the exponential integral @f$ E_n(x) @f$ * for large order. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * * This is something of an extension. * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint_large_n(unsigned int __n, _Tp __x) { const _Tp __xpn = __x + __n; const _Tp __xpn2 = __xpn * __xpn; _Tp __term = _Tp(1); _Tp __sum = _Tp(1); for (unsigned int __i = 1; __i <= __n; ++__i) { _Tp __prev = __term; __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return std::exp(-__x) * __sum / __xpn; } /** * @brief Return the exponential integral @f$ E_n(x) @f$. * * The exponential integral is given by * \f[ * E_n(x) = \int_{1}^\infty \frac{e^{-xt}}{t^n} dt * \f] * This is something of an extension. * * @param __n The order of the exponential integral function. * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template _Tp __expint(unsigned int __n, _Tp __x) { // Return NaN on NaN input. if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__n <= 1 && __x == _Tp(0)) return std::numeric_limits<_Tp>::infinity(); else { _Tp __E0 = std::exp(__x) / __x; if (__n == 0) return __E0; _Tp __E1 = __expint_E1(__x); if (__n == 1) return __E1; if (__x == _Tp(0)) return _Tp(1) / static_cast<_Tp>(__n - 1); _Tp __En = __expint_En_recursion(__n, __x); return __En; } } /** * @brief Return the exponential integral @f$ Ei(x) @f$. * * The exponential integral is given by * \f[ * Ei(x) = -\int_{-x}^\infty \frac{e^t}{t} dt * \f] * * @param __x The argument of the exponential integral function. * @return The exponential integral. */ template inline _Tp __expint(_Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __expint_Ei(__x); } } // namespace __detail #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC c++/8/tr1/ctime000064400000002322152640040200007005 0ustar00// TR1 ctime -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/ctime * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CTIME #define _GLIBCXX_TR1_CTIME 1 #include #endif // _GLIBCXX_TR1_CTIME c++/8/tr1/tuple000064400000027527152640040200007053 0ustar00// class template tuple -*- C++ -*- // Copyright (C) 2004-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/tuple * This is a TR1 C++ Library header. */ // Chris Jefferson // Variadic Templates support by Douglas Gregor #ifndef _GLIBCXX_TR1_TUPLE #define _GLIBCXX_TR1_TUPLE 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { // Adds a const reference to a non-reference type. template struct __add_c_ref { typedef const _Tp& type; }; template struct __add_c_ref<_Tp&> { typedef _Tp& type; }; // Adds a reference to a non-reference type. template struct __add_ref { typedef _Tp& type; }; template struct __add_ref<_Tp&> { typedef _Tp& type; }; /** * Contains the actual implementation of the @c tuple template, stored * as a recursive inheritance hierarchy from the first element (most * derived class) to the last (least derived class). The @c Idx * parameter gives the 0-based index of the element stored at this * point in the hierarchy; we use it to implement a constant-time * get() operation. */ template struct _Tuple_impl; /** * Zero-element tuple implementation. This is the basis case for the * inheritance recursion. */ template struct _Tuple_impl<_Idx> { }; /** * Recursive tuple implementation. Here we store the @c Head element * and derive from a @c Tuple_impl containing the remaining elements * (which contains the @c Tail). */ template struct _Tuple_impl<_Idx, _Head, _Tail...> : public _Tuple_impl<_Idx + 1, _Tail...> { typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; _Head _M_head; _Inherited& _M_tail() { return *this; } const _Inherited& _M_tail() const { return *this; } _Tuple_impl() : _Inherited(), _M_head() { } explicit _Tuple_impl(typename __add_c_ref<_Head>::type __head, typename __add_c_ref<_Tail>::type... __tail) : _Inherited(__tail...), _M_head(__head) { } template _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) : _Inherited(__in._M_tail()), _M_head(__in._M_head) { } _Tuple_impl(const _Tuple_impl& __in) : _Inherited(__in._M_tail()), _M_head(__in._M_head) { } template _Tuple_impl& operator=(const _Tuple_impl<_Idx, _UElements...>& __in) { _M_head = __in._M_head; _M_tail() = __in._M_tail(); return *this; } _Tuple_impl& operator=(const _Tuple_impl& __in) { _M_head = __in._M_head; _M_tail() = __in._M_tail(); return *this; } }; template class tuple : public _Tuple_impl<0, _Elements...> { typedef _Tuple_impl<0, _Elements...> _Inherited; public: tuple() : _Inherited() { } explicit tuple(typename __add_c_ref<_Elements>::type... __elements) : _Inherited(__elements...) { } template tuple(const tuple<_UElements...>& __in) : _Inherited(__in) { } tuple(const tuple& __in) : _Inherited(__in) { } template tuple& operator=(const tuple<_UElements...>& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& operator=(const tuple& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } }; template<> class tuple<> { }; // 2-element tuple, with construction and assignment from a pair. template class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> { typedef _Tuple_impl<0, _T1, _T2> _Inherited; public: tuple() : _Inherited() { } explicit tuple(typename __add_c_ref<_T1>::type __a1, typename __add_c_ref<_T2>::type __a2) : _Inherited(__a1, __a2) { } template tuple(const tuple<_U1, _U2>& __in) : _Inherited(__in) { } tuple(const tuple& __in) : _Inherited(__in) { } template tuple(const pair<_U1, _U2>& __in) : _Inherited(_Tuple_impl<0, typename __add_c_ref<_U1>::type, typename __add_c_ref<_U2>::type>(__in.first, __in.second)) { } template tuple& operator=(const tuple<_U1, _U2>& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& operator=(const tuple& __in) { static_cast<_Inherited&>(*this) = __in; return *this; } template tuple& operator=(const pair<_U1, _U2>& __in) { this->_M_head = __in.first; this->_M_tail()._M_head = __in.second; return *this; } }; /// Gives the type of the ith element of a given tuple type. template struct tuple_element; /** * Recursive case for tuple_element: strip off the first element in * the tuple and retrieve the (i-1)th element of the remaining tuple. */ template struct tuple_element<__i, tuple<_Head, _Tail...> > : tuple_element<__i - 1, tuple<_Tail...> > { }; /** * Basis case for tuple_element: The first element is the one we're seeking. */ template struct tuple_element<0, tuple<_Head, _Tail...> > { typedef _Head type; }; /// Finds the size of a given tuple type. template struct tuple_size; /// class tuple_size template struct tuple_size > { static const int value = sizeof...(_Elements); }; template const int tuple_size >::value; template inline typename __add_ref<_Head>::type __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) { return __t._M_head; } template inline typename __add_c_ref<_Head>::type __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) { return __t._M_head; } // Return a reference (const reference) to the ith element of a tuple. // Any const or non-const ref elements are returned with their original type. template inline typename __add_ref< typename tuple_element<__i, tuple<_Elements...> >::type >::type get(tuple<_Elements...>& __t) { return __get_helper<__i>(__t); } template inline typename __add_c_ref< typename tuple_element<__i, tuple<_Elements...> >::type >::type get(const tuple<_Elements...>& __t) { return __get_helper<__i>(__t); } // This class helps construct the various comparison operations on tuples template struct __tuple_compare; template struct __tuple_compare<0, __i, __j, _Tp, _Up> { static bool __eq(const _Tp& __t, const _Up& __u) { return (get<__i>(__t) == get<__i>(__u) && __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u)); } static bool __less(const _Tp& __t, const _Up& __u) { return ((get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) && __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u)); } }; template struct __tuple_compare<0, __i, __i, _Tp, _Up> { static bool __eq(const _Tp&, const _Up&) { return true; } static bool __less(const _Tp&, const _Up&) { return false; } }; template bool operator==(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { typedef tuple<_TElements...> _Tp; typedef tuple<_UElements...> _Up; return (__tuple_compare::value - tuple_size<_Up>::value, 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u)); } template bool operator<(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { typedef tuple<_TElements...> _Tp; typedef tuple<_UElements...> _Up; return (__tuple_compare::value - tuple_size<_Up>::value, 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u)); } template inline bool operator!=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__t == __u); } template inline bool operator>(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return __u < __t; } template inline bool operator<=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__u < __t); } template inline bool operator>=(const tuple<_TElements...>& __t, const tuple<_UElements...>& __u) { return !(__t < __u); } template class reference_wrapper; // Helper which adds a reference to a type when given a reference_wrapper template struct __strip_reference_wrapper { typedef _Tp __type; }; template struct __strip_reference_wrapper > { typedef _Tp& __type; }; template struct __strip_reference_wrapper > { typedef _Tp& __type; }; template inline tuple::__type...> make_tuple(_Elements... __args) { typedef tuple::__type...> __result_type; return __result_type(__args...); } template inline tuple<_Elements&...> tie(_Elements&... __args) { return tuple<_Elements&...>(__args...); } // A class (and instance) which can be used in 'tie' when an element // of a tuple is not required struct _Swallow_assign { template _Swallow_assign& operator=(const _Tp&) { return *this; } }; // TODO: Put this in some kind of shared file. namespace { _Swallow_assign ignore; }; // anonymous namespace } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_TUPLE c++/8/tr1/stdarg.h000064400000002276152640040200007426 0ustar00// TR1 stdarg.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/stdarg.h * This is a TR1 C++ Library header. */ #ifndef _TR1_STDARG_H #define _TR1_STDARG_H 1 #include #endif c++/8/tr1/cstdlib000064400000003404152640040200007332 0ustar00// TR1 cstdlib -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cstdlib * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CSTDLIB #define _GLIBCXX_TR1_CSTDLIB 1 #pragma GCC system_header #include #if _GLIBCXX_HOSTED #if _GLIBCXX_USE_C99_STDLIB namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC // types using std::lldiv_t; // functions using std::llabs; using std::lldiv; #endif using std::atoll; using std::strtoll; using std::strtoull; using std::strtof; using std::strtold; // overloads using std::abs; #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC using std::div; #endif } } #endif // _GLIBCXX_USE_C99_STDLIB #endif // _GLIBCXX_HOSTED #endif // _GLIBCXX_TR1_CSTDLIB c++/8/tr1/wchar.h000064400000002341152640040200007237 0ustar00// TR1 wchar.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/wchar.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_WCHAR_H #define _GLIBCXX_TR1_WCHAR_H 1 #include #endif // _GLIBCXX_TR1_WCHAR_H c++/8/tr1/stdlib.h000064400000002717152640040200007423 0ustar00// TR1 stdlib.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/stdlib.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_STDLIB_H #define _GLIBCXX_TR1_STDLIB_H 1 #include #if _GLIBCXX_HOSTED #if _GLIBCXX_USE_C99_STDLIB using std::tr1::atoll; using std::tr1::strtoll; using std::tr1::strtoull; using std::tr1::abs; #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC using std::tr1::div; #endif #endif #endif #endif // _GLIBCXX_TR1_STDLIB_H c++/8/tr1/ctype.h000064400000002271152640040200007261 0ustar00// TR1 ctype.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/ctype.h * This is a TR1 C++ Library header. */ #ifndef _TR1_CTYPE_H #define _TR1_CTYPE_H 1 #include #endif c++/8/tr1/poly_laguerre.tcc000064400000026634152640040200011341 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/poly_laguerre.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // Ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 13, pp. 509-510, Section 22 pp. 773-802 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl #ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC #define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief This routine returns the associated Laguerre polynomial * of order @f$ n @f$, degree @f$ \alpha @f$ for large n. * Abramowitz & Stegun, 13.5.21 * * @param __n The order of the Laguerre function. * @param __alpha The degree of the Laguerre function. * @param __x The argument of the Laguerre function. * @return The value of the Laguerre function of order n, * degree @f$ \alpha @f$, and argument x. * * This is from the GNU Scientific Library. */ template _Tp __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) { const _Tp __a = -_Tp(__n); const _Tp __b = _Tp(__alpha1) + _Tp(1); const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; const _Tp __cos2th = __x / __eta; const _Tp __sin2th = _Tp(1) - __cos2th; const _Tp __th = std::acos(std::sqrt(__cos2th)); const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() * __numeric_constants<_Tp>::__pi_2() * __eta * __eta * __cos2th * __sin2th; #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __lg_b = _GLIBCXX_MATH_NS::lgamma(_Tp(__n) + __b); const _Tp __lnfact = _GLIBCXX_MATH_NS::lgamma(_Tp(__n + 1)); #else const _Tp __lg_b = __log_gamma(_Tp(__n) + __b); const _Tp __lnfact = __log_gamma(_Tp(__n + 1)); #endif _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) * std::log(_Tp(0.25L) * __x * __eta); _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + __pre_term1 - __pre_term2; _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta * (_Tp(2) * __th - std::sin(_Tp(2) * __th)) + __numeric_constants<_Tp>::__pi_4()); _Tp __ser = __ser_term1 + __ser_term2; return std::exp(__lnpre) * __ser; } /** * @brief Evaluate the polynomial based on the confluent hypergeometric * function in a safe way, with no restriction on the arguments. * * The associated Laguerre function is defined by * @f[ * L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!} * _1F_1(-n; \alpha + 1; x) * @f] * where @f$ (\alpha)_n @f$ is the Pochhammer symbol and * @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function. * * This function assumes x != 0. * * This is from the GNU Scientific Library. */ template _Tp __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) { const _Tp __b = _Tp(__alpha1) + _Tp(1); const _Tp __mx = -__x; const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); // Get |x|^n/n! _Tp __tc = _Tp(1); const _Tp __ax = std::abs(__x); for (unsigned int __k = 1; __k <= __n; ++__k) __tc *= (__ax / __k); _Tp __term = __tc * __tc_sgn; _Tp __sum = __term; for (int __k = int(__n) - 1; __k >= 0; --__k) { __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) * _Tp(__k + 1) / __mx; __sum += __term; } return __sum; } /** * @brief This routine returns the associated Laguerre polynomial * of order @f$ n @f$, degree @f$ \alpha @f$: @f$ L_n^\alpha(x) @f$ * by recursion. * * The associated Laguerre function is defined by * @f[ * L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!} * _1F_1(-n; \alpha + 1; x) * @f] * where @f$ (\alpha)_n @f$ is the Pochhammer symbol and * @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function. * * The associated Laguerre polynomial is defined for integral * @f$ \alpha = m @f$ by: * @f[ * L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x) * @f] * where the Laguerre polynomial is defined by: * @f[ * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x}) * @f] * * @param __n The order of the Laguerre function. * @param __alpha The degree of the Laguerre function. * @param __x The argument of the Laguerre function. * @return The value of the Laguerre function of order n, * degree @f$ \alpha @f$, and argument x. */ template _Tp __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) { // Compute l_0. _Tp __l_0 = _Tp(1); if (__n == 0) return __l_0; // Compute l_1^alpha. _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); if (__n == 1) return __l_1; // Compute l_n^alpha by recursion on n. _Tp __l_n2 = __l_0; _Tp __l_n1 = __l_1; _Tp __l_n = _Tp(0); for (unsigned int __nn = 2; __nn <= __n; ++__nn) { __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) * __l_n1 / _Tp(__nn) - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); __l_n2 = __l_n1; __l_n1 = __l_n; } return __l_n; } /** * @brief This routine returns the associated Laguerre polynomial * of order n, degree @f$ \alpha @f$: @f$ L_n^alpha(x) @f$. * * The associated Laguerre function is defined by * @f[ * L_n^\alpha(x) = \frac{(\alpha + 1)_n}{n!} * _1F_1(-n; \alpha + 1; x) * @f] * where @f$ (\alpha)_n @f$ is the Pochhammer symbol and * @f$ _1F_1(a; c; x) @f$ is the confluent hypergeometric function. * * The associated Laguerre polynomial is defined for integral * @f$ \alpha = m @f$ by: * @f[ * L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x) * @f] * where the Laguerre polynomial is defined by: * @f[ * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x}) * @f] * * @param __n The order of the Laguerre function. * @param __alpha The degree of the Laguerre function. * @param __x The argument of the Laguerre function. * @return The value of the Laguerre function of order n, * degree @f$ \alpha @f$, and argument x. */ template _Tp __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(__N("Negative argument " "in __poly_laguerre.")); // Return NaN on NaN input. else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__n == 0) return _Tp(1); else if (__n == 1) return _Tp(1) + _Tp(__alpha1) - __x; else if (__x == _Tp(0)) { _Tp __prod = _Tp(__alpha1) + _Tp(1); for (unsigned int __k = 2; __k <= __n; ++__k) __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); return __prod; } else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) return __poly_laguerre_large_n(__n, __alpha1, __x); else if (_Tp(__alpha1) >= _Tp(0) || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) return __poly_laguerre_recursion(__n, __alpha1, __x); else return __poly_laguerre_hyperg(__n, __alpha1, __x); } /** * @brief This routine returns the associated Laguerre polynomial * of order n, degree m: @f$ L_n^m(x) @f$. * * The associated Laguerre polynomial is defined for integral * @f$ \alpha = m @f$ by: * @f[ * L_n^m(x) = (-1)^m \frac{d^m}{dx^m} L_{n + m}(x) * @f] * where the Laguerre polynomial is defined by: * @f[ * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x}) * @f] * * @param __n The order of the Laguerre polynomial. * @param __m The degree of the Laguerre polynomial. * @param __x The argument of the Laguerre polynomial. * @return The value of the associated Laguerre polynomial of order n, * degree m, and argument x. */ template inline _Tp __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) { return __poly_laguerre(__n, __m, __x); } /** * @brief This routine returns the Laguerre polynomial * of order n: @f$ L_n(x) @f$. * * The Laguerre polynomial is defined by: * @f[ * L_n(x) = \frac{e^x}{n!} \frac{d^n}{dx^n} (x^ne^{-x}) * @f] * * @param __n The order of the Laguerre polynomial. * @param __x The argument of the Laguerre polynomial. * @return The value of the Laguerre polynomial of order n * and argument x. */ template inline _Tp __laguerre(unsigned int __n, _Tp __x) { return __poly_laguerre(__n, 0, __x); } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC c++/8/tr1/complex000064400000030140152640040200007352 0ustar00// TR1 complex -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/complex * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_COMPLEX #define _GLIBCXX_TR1_COMPLEX 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @addtogroup complex_numbers * @{ */ #if __cplusplus >= 201103L using std::acos; using std::asin; using std::atan; using std::acosh; using std::asinh; using std::atanh; #else template std::complex<_Tp> acos(const std::complex<_Tp>&); template std::complex<_Tp> asin(const std::complex<_Tp>&); template std::complex<_Tp> atan(const std::complex<_Tp>&); template std::complex<_Tp> acosh(const std::complex<_Tp>&); template std::complex<_Tp> asinh(const std::complex<_Tp>&); template std::complex<_Tp> atanh(const std::complex<_Tp>&); #endif // The std::fabs return type in C++11 mode is different (just _Tp). template std::complex<_Tp> fabs(const std::complex<_Tp>&); #if __cplusplus < 201103L template inline std::complex<_Tp> __complex_acos(const std::complex<_Tp>& __z) { const std::complex<_Tp> __t = std::tr1::asin(__z); const _Tp __pi_2 = 1.5707963267948966192313216916397514L; return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_acos(__complex__ float __z) { return __builtin_cacosf(__z); } inline __complex__ double __complex_acos(__complex__ double __z) { return __builtin_cacos(__z); } inline __complex__ long double __complex_acos(const __complex__ long double& __z) { return __builtin_cacosl(__z); } template inline std::complex<_Tp> acos(const std::complex<_Tp>& __z) { return __complex_acos(__z.__rep()); } #else /// acos(__z) [8.1.2]. // Effects: Behaves the same as C99 function cacos, defined // in subclause 7.3.5.1. template inline std::complex<_Tp> acos(const std::complex<_Tp>& __z) { return __complex_acos(__z); } #endif template inline std::complex<_Tp> __complex_asin(const std::complex<_Tp>& __z) { std::complex<_Tp> __t(-__z.imag(), __z.real()); __t = std::tr1::asinh(__t); return std::complex<_Tp>(__t.imag(), -__t.real()); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_asin(__complex__ float __z) { return __builtin_casinf(__z); } inline __complex__ double __complex_asin(__complex__ double __z) { return __builtin_casin(__z); } inline __complex__ long double __complex_asin(const __complex__ long double& __z) { return __builtin_casinl(__z); } template inline std::complex<_Tp> asin(const std::complex<_Tp>& __z) { return __complex_asin(__z.__rep()); } #else /// asin(__z) [8.1.3]. // Effects: Behaves the same as C99 function casin, defined // in subclause 7.3.5.2. template inline std::complex<_Tp> asin(const std::complex<_Tp>& __z) { return __complex_asin(__z); } #endif template std::complex<_Tp> __complex_atan(const std::complex<_Tp>& __z) { const _Tp __r2 = __z.real() * __z.real(); const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); _Tp __num = __z.imag() + _Tp(1.0); _Tp __den = __z.imag() - _Tp(1.0); __num = __r2 + __num * __num; __den = __r2 + __den * __den; return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), _Tp(0.25) * log(__num / __den)); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_atan(__complex__ float __z) { return __builtin_catanf(__z); } inline __complex__ double __complex_atan(__complex__ double __z) { return __builtin_catan(__z); } inline __complex__ long double __complex_atan(const __complex__ long double& __z) { return __builtin_catanl(__z); } template inline std::complex<_Tp> atan(const std::complex<_Tp>& __z) { return __complex_atan(__z.__rep()); } #else /// atan(__z) [8.1.4]. // Effects: Behaves the same as C99 function catan, defined // in subclause 7.3.5.3. template inline std::complex<_Tp> atan(const std::complex<_Tp>& __z) { return __complex_atan(__z); } #endif template std::complex<_Tp> __complex_acosh(const std::complex<_Tp>& __z) { // Kahan's formula. return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0))) + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0)))); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_acosh(__complex__ float __z) { return __builtin_cacoshf(__z); } inline __complex__ double __complex_acosh(__complex__ double __z) { return __builtin_cacosh(__z); } inline __complex__ long double __complex_acosh(const __complex__ long double& __z) { return __builtin_cacoshl(__z); } template inline std::complex<_Tp> acosh(const std::complex<_Tp>& __z) { return __complex_acosh(__z.__rep()); } #else /// acosh(__z) [8.1.5]. // Effects: Behaves the same as C99 function cacosh, defined // in subclause 7.3.6.1. template inline std::complex<_Tp> acosh(const std::complex<_Tp>& __z) { return __complex_acosh(__z); } #endif template std::complex<_Tp> __complex_asinh(const std::complex<_Tp>& __z) { std::complex<_Tp> __t((__z.real() - __z.imag()) * (__z.real() + __z.imag()) + _Tp(1.0), _Tp(2.0) * __z.real() * __z.imag()); __t = std::sqrt(__t); return std::log(__t + __z); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_asinh(__complex__ float __z) { return __builtin_casinhf(__z); } inline __complex__ double __complex_asinh(__complex__ double __z) { return __builtin_casinh(__z); } inline __complex__ long double __complex_asinh(const __complex__ long double& __z) { return __builtin_casinhl(__z); } template inline std::complex<_Tp> asinh(const std::complex<_Tp>& __z) { return __complex_asinh(__z.__rep()); } #else /// asinh(__z) [8.1.6]. // Effects: Behaves the same as C99 function casin, defined // in subclause 7.3.6.2. template inline std::complex<_Tp> asinh(const std::complex<_Tp>& __z) { return __complex_asinh(__z); } #endif template std::complex<_Tp> __complex_atanh(const std::complex<_Tp>& __z) { const _Tp __i2 = __z.imag() * __z.imag(); const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); _Tp __num = _Tp(1.0) + __z.real(); _Tp __den = _Tp(1.0) - __z.real(); __num = __i2 + __num * __num; __den = __i2 + __den * __den; return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); } #if _GLIBCXX_USE_C99_COMPLEX_TR1 inline __complex__ float __complex_atanh(__complex__ float __z) { return __builtin_catanhf(__z); } inline __complex__ double __complex_atanh(__complex__ double __z) { return __builtin_catanh(__z); } inline __complex__ long double __complex_atanh(const __complex__ long double& __z) { return __builtin_catanhl(__z); } template inline std::complex<_Tp> atanh(const std::complex<_Tp>& __z) { return __complex_atanh(__z.__rep()); } #else /// atanh(__z) [8.1.7]. // Effects: Behaves the same as C99 function catanh, defined // in subclause 7.3.6.3. template inline std::complex<_Tp> atanh(const std::complex<_Tp>& __z) { return __complex_atanh(__z); } #endif #endif // C++11 template inline std::complex<_Tp> /// fabs(__z) [8.1.8]. // Effects: Behaves the same as C99 function cabs, defined // in subclause 7.3.8.1. fabs(const std::complex<_Tp>& __z) { return std::abs(__z); } /// Additional overloads [8.1.9]. #if __cplusplus < 201103L template inline typename __gnu_cxx::__promote<_Tp>::__type arg(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L) : __type(); #else return std::arg(std::complex<__type>(__x)); #endif } template inline typename __gnu_cxx::__promote<_Tp>::__type imag(_Tp) { return _Tp(); } template inline typename __gnu_cxx::__promote<_Tp>::__type norm(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __type(__x) * __type(__x); } template inline typename __gnu_cxx::__promote<_Tp>::__type real(_Tp __x) { return __x; } #endif template inline std::complex::__type> pow(const std::complex<_Tp>& __x, const _Up& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(std::complex<__type>(__x), __type(__y)); } template inline std::complex::__type> pow(const _Tp& __x, const std::complex<_Up>& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(__type(__x), std::complex<__type>(__y)); } template inline std::complex::__type> pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(std::complex<__type>(__x), std::complex<__type>(__y)); } using std::arg; template inline std::complex<_Tp> conj(const std::complex<_Tp>& __z) { return std::conj(__z); } template inline std::complex::__type> conj(_Tp __x) { return __x; } using std::imag; using std::norm; using std::polar; template inline std::complex::__type> polar(const _Tp& __rho, const _Up& __theta) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::polar(__type(__rho), __type(__theta)); } using std::real; template inline std::complex<_Tp> pow(const std::complex<_Tp>& __x, const _Tp& __y) { return std::pow(__x, __y); } template inline std::complex<_Tp> pow(const _Tp& __x, const std::complex<_Tp>& __y) { return std::pow(__x, __y); } template inline std::complex<_Tp> pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y) { return std::pow(__x, __y); } // @} group complex_numbers } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_COMPLEX c++/8/tr1/cstdarg000064400000002336152640040200007340 0ustar00// TR1 cstdarg -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cstdarg * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CSTDARG #define _GLIBCXX_TR1_CSTDARG 1 #include #endif // _GLIBCXX_TR1_CSTDARG c++/8/tr1/cstdint000064400000005077152640040200007366 0ustar00// TR1 cstdint -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cstdint * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CSTDINT #define _GLIBCXX_TR1_CSTDINT 1 #pragma GCC system_header #include // For 8.22.1/1 (see C99, Notes 219, 220, 222) # if _GLIBCXX_HAVE_STDINT_H # ifndef __STDC_LIMIT_MACROS # define _UNDEF__STDC_LIMIT_MACROS # define __STDC_LIMIT_MACROS # endif # ifndef __STDC_CONSTANT_MACROS # define _UNDEF__STDC_CONSTANT_MACROS # define __STDC_CONSTANT_MACROS # endif # include # ifdef _UNDEF__STDC_LIMIT_MACROS # undef __STDC_LIMIT_MACROS # undef _UNDEF__STDC_LIMIT_MACROS # endif # ifdef _UNDEF__STDC_CONSTANT_MACROS # undef __STDC_CONSTANT_MACROS # undef _UNDEF__STDC_CONSTANT_MACROS # endif # endif #ifdef _GLIBCXX_USE_C99_STDINT_TR1 namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { using ::int8_t; using ::int16_t; using ::int32_t; using ::int64_t; using ::int_fast8_t; using ::int_fast16_t; using ::int_fast32_t; using ::int_fast64_t; using ::int_least8_t; using ::int_least16_t; using ::int_least32_t; using ::int_least64_t; using ::intmax_t; using ::intptr_t; using ::uint8_t; using ::uint16_t; using ::uint32_t; using ::uint64_t; using ::uint_fast8_t; using ::uint_fast16_t; using ::uint_fast32_t; using ::uint_fast64_t; using ::uint_least8_t; using ::uint_least16_t; using ::uint_least32_t; using ::uint_least64_t; using ::uintmax_t; using ::uintptr_t; } } #endif // _GLIBCXX_USE_C99_STDINT_TR1 #endif // _GLIBCXX_TR1_CSTDINT c++/8/tr1/functional_hash.h000064400000013633152640040200011306 0ustar00// TR1 functional_hash.h header -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/functional_hash.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/functional} */ #ifndef _GLIBCXX_TR1_FUNCTIONAL_HASH_H #define _GLIBCXX_TR1_FUNCTIONAL_HASH_H 1 #pragma GCC system_header namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /// Class template hash. // Declaration of default hash functor std::tr1::hash. The types for // which std::tr1::hash is well-defined is in clause 6.3.3. of the PDTR. template struct hash : public std::unary_function<_Tp, size_t> { size_t operator()(_Tp __val) const; }; /// Partial specializations for pointer types. template struct hash<_Tp*> : public std::unary_function<_Tp*, size_t> { size_t operator()(_Tp* __p) const { return reinterpret_cast(__p); } }; /// Explicit specializations for integer types. #define _TR1_hashtable_define_trivial_hash(_Tp) \ template<> \ inline size_t \ hash<_Tp>::operator()(_Tp __val) const \ { return static_cast(__val); } _TR1_hashtable_define_trivial_hash(bool); _TR1_hashtable_define_trivial_hash(char); _TR1_hashtable_define_trivial_hash(signed char); _TR1_hashtable_define_trivial_hash(unsigned char); _TR1_hashtable_define_trivial_hash(wchar_t); _TR1_hashtable_define_trivial_hash(short); _TR1_hashtable_define_trivial_hash(int); _TR1_hashtable_define_trivial_hash(long); _TR1_hashtable_define_trivial_hash(long long); _TR1_hashtable_define_trivial_hash(unsigned short); _TR1_hashtable_define_trivial_hash(unsigned int); _TR1_hashtable_define_trivial_hash(unsigned long); _TR1_hashtable_define_trivial_hash(unsigned long long); #undef _TR1_hashtable_define_trivial_hash // Fowler / Noll / Vo (FNV) Hash (type FNV-1a) // (Used by the next specializations of std::tr1::hash.) // N.B. These functions should work on unsigned char, otherwise they do not // correctly implement the FNV-1a algorithm (see PR59406). // The existing behaviour is retained for backwards compatibility. /// Dummy generic implementation (for sizeof(size_t) != 4, 8). template struct _Fnv_hash_base { template static size_t hash(const _Tp* __ptr, size_t __clength) { size_t __result = 0; const char* __cptr = reinterpret_cast(__ptr); for (; __clength; --__clength) __result = (__result * 131) + *__cptr++; return __result; } }; template<> struct _Fnv_hash_base<4> { template static size_t hash(const _Tp* __ptr, size_t __clength) { size_t __result = static_cast(2166136261UL); const char* __cptr = reinterpret_cast(__ptr); for (; __clength; --__clength) { __result ^= static_cast(*__cptr++); __result *= static_cast(16777619UL); } return __result; } }; template<> struct _Fnv_hash_base<8> { template static size_t hash(const _Tp* __ptr, size_t __clength) { size_t __result = static_cast(14695981039346656037ULL); const char* __cptr = reinterpret_cast(__ptr); for (; __clength; --__clength) { __result ^= static_cast(*__cptr++); __result *= static_cast(1099511628211ULL); } return __result; } }; struct _Fnv_hash : public _Fnv_hash_base { using _Fnv_hash_base::hash; template static size_t hash(const _Tp& __val) { return hash(&__val, sizeof(__val)); } }; /// Explicit specializations for float. template<> inline size_t hash::operator()(float __val) const { // 0 and -0 both hash to zero. return __val != 0.0f ? std::tr1::_Fnv_hash::hash(__val) : 0; } /// Explicit specializations for double. template<> inline size_t hash::operator()(double __val) const { // 0 and -0 both hash to zero. return __val != 0.0 ? std::tr1::_Fnv_hash::hash(__val) : 0; } /// Explicit specializations for long double. template<> _GLIBCXX_PURE size_t hash::operator()(long double __val) const; /// Explicit specialization of member operator for non-builtin types. template<> _GLIBCXX_PURE size_t hash::operator()(string) const; template<> _GLIBCXX_PURE size_t hash::operator()(const string&) const; #ifdef _GLIBCXX_USE_WCHAR_T template<> _GLIBCXX_PURE size_t hash::operator()(wstring) const; template<> _GLIBCXX_PURE size_t hash::operator()(const wstring&) const; #endif } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H c++/8/tr1/regex000064400000265320152640040200007027 0ustar00// class template regex -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** * @file tr1/regex * @author Stephen M. Webb * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_REGEX #define _GLIBCXX_TR1_REGEX 1 #pragma GCC system_header #include #include #include #include #include #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @defgroup tr1_regex Regular Expressions * A facility for performing regular expression pattern matching. */ //@{ /** @namespace std::regex_constants * @brief ISO C++ 0x entities sub namespace for regex. */ namespace regex_constants { /** * @name 5.1 Regular Expression Syntax Options */ //@{ enum __syntax_option { _S_icase, _S_nosubs, _S_optimize, _S_collate, _S_ECMAScript, _S_basic, _S_extended, _S_awk, _S_grep, _S_egrep, _S_syntax_last }; /** * @brief This is a bitmask type indicating how to interpret the regex. * * The @c syntax_option_type is implementation defined but it is valid to * perform bitwise operations on these values and expect the right thing to * happen. * * A valid value of type syntax_option_type shall have exactly one of the * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep * %set. */ typedef unsigned int syntax_option_type; /** * Specifies that the matching of regular expressions against a character * sequence shall be performed without regard to case. */ static const syntax_option_type icase = 1 << _S_icase; /** * Specifies that when a regular expression is matched against a character * container sequence, no sub-expression matches are to be stored in the * supplied match_results structure. */ static const syntax_option_type nosubs = 1 << _S_nosubs; /** * Specifies that the regular expression engine should pay more attention to * the speed with which regular expressions are matched, and less to the * speed with which regular expression objects are constructed. Otherwise * it has no detectable effect on the program output. */ static const syntax_option_type optimize = 1 << _S_optimize; /** * Specifies that character ranges of the form [a-b] should be locale * sensitive. */ static const syntax_option_type collate = 1 << _S_collate; /** * Specifies that the grammar recognized by the regular expression engine is * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript * Language Specification, Standard Ecma-262, third edition, 1999], as * modified in tr1 section [7.13]. This grammar is similar to that defined * in the PERL scripting language but extended with elements found in the * POSIX regular expression grammar. */ static const syntax_option_type ECMAScript = 1 << _S_ECMAScript; /** * Specifies that the grammar recognized by the regular expression engine is * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001, * Portable Operating System Interface (POSIX), Base Definitions and * Headers, Section 9, Regular Expressions [IEEE, Information Technology -- * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. */ static const syntax_option_type basic = 1 << _S_basic; /** * Specifies that the grammar recognized by the regular expression engine is * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001, * Portable Operating System Interface (POSIX), Base Definitions and Headers, * Section 9, Regular Expressions. */ static const syntax_option_type extended = 1 << _S_extended; /** * Specifies that the grammar recognized by the regular expression engine is * that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is * identical to syntax_option_type extended, except that C-style escape * sequences are supported. These sequences are: * \\\\, \\a, \\b, \\f, * \\n, \\r, \\t , \\v, * \\', ', and \\ddd * (where ddd is one, two, or three octal digits). */ static const syntax_option_type awk = 1 << _S_awk; /** * Specifies that the grammar recognized by the regular expression engine is * that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is * identical to syntax_option_type basic, except that newlines are treated * as whitespace. */ static const syntax_option_type grep = 1 << _S_grep; /** * Specifies that the grammar recognized by the regular expression engine is * that used by POSIX utility grep when given the -E option in * IEEE Std 1003.1-2001. This option is identical to syntax_option_type * extended, except that newlines are treated as whitespace. */ static const syntax_option_type egrep = 1 << _S_egrep; //@} /** * @name 5.2 Matching Rules * * Matching a regular expression against a sequence of characters [first, * last) proceeds according to the rules of the grammar specified for the * regular expression object, modified according to the effects listed * below for any bitmask elements set. * */ //@{ enum __match_flag { _S_not_bol, _S_not_eol, _S_not_bow, _S_not_eow, _S_any, _S_not_null, _S_continuous, _S_prev_avail, _S_sed, _S_no_copy, _S_first_only, _S_match_flag_last }; /** * @brief This is a bitmask type indicating regex matching rules. * * The @c match_flag_type is implementation defined but it is valid to * perform bitwise operations on these values and expect the right thing to * happen. */ typedef std::bitset<_S_match_flag_last> match_flag_type; /** * The default matching rules. */ static const match_flag_type match_default = 0; /** * The first character in the sequence [first, last) is treated as though it * is not at the beginning of a line, so the character (^) in the regular * expression shall not match [first, first). */ static const match_flag_type match_not_bol = 1 << _S_not_bol; /** * The last character in the sequence [first, last) is treated as though it * is not at the end of a line, so the character ($) in the regular * expression shall not match [last, last). */ static const match_flag_type match_not_eol = 1 << _S_not_eol; /** * The expression \\b is not matched against the sub-sequence * [first,first). */ static const match_flag_type match_not_bow = 1 << _S_not_bow; /** * The expression \\b should not be matched against the sub-sequence * [last,last). */ static const match_flag_type match_not_eow = 1 << _S_not_eow; /** * If more than one match is possible then any match is an acceptable * result. */ static const match_flag_type match_any = 1 << _S_any; /** * The expression does not match an empty sequence. */ static const match_flag_type match_not_null = 1 << _S_not_null; /** * The expression only matches a sub-sequence that begins at first . */ static const match_flag_type match_continuous = 1 << _S_continuous; /** * --first is a valid iterator position. When this flag is set then the * flags match_not_bol and match_not_bow are ignored by the regular * expression algorithms 7.11 and iterators 7.12. */ static const match_flag_type match_prev_avail = 1 << _S_prev_avail; /** * When a regular expression match is to be replaced by a new string, the * new string is constructed using the rules used by the ECMAScript replace * function in ECMA- 262 [Ecma International, ECMAScript Language * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11 * String.prototype.replace. In addition, during search and replace * operations all non-overlapping occurrences of the regular expression * are located and replaced, and sections of the input that did not match * the expression are copied unchanged to the output string. * * Format strings (from ECMA-262 [15.5.4.11]): * @li $$ The dollar-sign itself ($) * @li $& The matched substring. * @li $` The portion of @a string that precedes the matched substring. * This would be match_results::prefix(). * @li $' The portion of @a string that follows the matched substring. * This would be match_results::suffix(). * @li $n The nth capture, where n is in [1,9] and $n is not followed by a * decimal digit. If n <= match_results::size() and the nth capture * is undefined, use the empty string instead. If n > * match_results::size(), the result is implementation-defined. * @li $nn The nnth capture, where nn is a two-digit decimal number on * [01, 99]. If nn <= match_results::size() and the nth capture is * undefined, use the empty string instead. If * nn > match_results::size(), the result is implementation-defined. */ static const match_flag_type format_default = 0; /** * When a regular expression match is to be replaced by a new string, the * new string is constructed using the rules used by the POSIX sed utility * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable * Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. */ static const match_flag_type format_sed = 1 << _S_sed; /** * During a search and replace operation, sections of the character * container sequence being searched that do not match the regular * expression shall not be copied to the output string. */ static const match_flag_type format_no_copy = 1 << _S_no_copy; /** * When specified during a search and replace operation, only the first * occurrence of the regular expression shall be replaced. */ static const match_flag_type format_first_only = 1 << _S_first_only; //@} /** * @name 5.3 Error Types */ //@{ enum error_type { _S_error_collate, _S_error_ctype, _S_error_escape, _S_error_backref, _S_error_brack, _S_error_paren, _S_error_brace, _S_error_badbrace, _S_error_range, _S_error_space, _S_error_badrepeat, _S_error_complexity, _S_error_stack, _S_error_last }; /** The expression contained an invalid collating element name. */ static const error_type error_collate(_S_error_collate); /** The expression contained an invalid character class name. */ static const error_type error_ctype(_S_error_ctype); /** * The expression contained an invalid escaped character, or a trailing * escape. */ static const error_type error_escape(_S_error_escape); /** The expression contained an invalid back reference. */ static const error_type error_backref(_S_error_backref); /** The expression contained mismatched [ and ]. */ static const error_type error_brack(_S_error_brack); /** The expression contained mismatched ( and ). */ static const error_type error_paren(_S_error_paren); /** The expression contained mismatched { and } */ static const error_type error_brace(_S_error_brace); /** The expression contained an invalid range in a {} expression. */ static const error_type error_badbrace(_S_error_badbrace); /** * The expression contained an invalid character range, * such as [b-a] in most encodings. */ static const error_type error_range(_S_error_range); /** * There was insufficient memory to convert the expression into a * finite state machine. */ static const error_type error_space(_S_error_space); /** * One of *?+{ was not preceded by a valid regular expression. */ static const error_type error_badrepeat(_S_error_badrepeat); /** * The complexity of an attempted match against a regular expression * exceeded a pre-set level. */ static const error_type error_complexity(_S_error_complexity); /** * There was insufficient memory to determine whether the * regular expression could match the specified character sequence. */ static const error_type error_stack(_S_error_stack); //@} } // [7.8] Class regex_error /** * @brief A regular expression exception class. * @ingroup exceptions * * The regular expression library throws objects of this class on error. */ class regex_error : public std::runtime_error { public: /** * @brief Constructs a regex_error object. * * @param ecode the regex error code. */ explicit regex_error(regex_constants::error_type __ecode) : std::runtime_error("regex_error"), _M_code(__ecode) { } /** * @brief Gets the regex error code. * * @returns the regex error code. */ regex_constants::error_type code() const { return _M_code; } protected: regex_constants::error_type _M_code; }; // [7.7] Class regex_traits /** * @brief Describes aspects of a regular expression. * * A regular expression traits class that satisfies the requirements of tr1 * section [7.2]. * * The class %regex is parameterized around a set of related types and * functions used to complete the definition of its semantics. This class * satisfies the requirements of such a traits class. */ template struct regex_traits { public: typedef _Ch_type char_type; typedef std::basic_string string_type; typedef std::locale locale_type; typedef std::ctype_base::mask char_class_type; public: /** * @brief Constructs a default traits object. */ regex_traits() { } /** * @brief Gives the length of a C-style string starting at @p __p. * * @param __p a pointer to the start of a character sequence. * * @returns the number of characters between @p *__p and the first * default-initialized value of type @p char_type. In other words, uses * the C-string algorithm for determining the length of a sequence of * characters. */ static std::size_t length(const char_type* __p) { return string_type::traits_type::length(__p); } /** * @brief Performs the identity translation. * * @param c A character to the locale-specific character set. * * @returns c. */ char_type translate(char_type __c) const { return __c; } /** * @brief Translates a character into a case-insensitive equivalent. * * @param c A character to the locale-specific character set. * * @returns the locale-specific lower-case equivalent of c. * @throws std::bad_cast if the imbued locale does not support the ctype * facet. */ char_type translate_nocase(char_type __c) const { using std::ctype; using std::use_facet; return use_facet >(_M_locale).tolower(__c); } /** * @brief Gets a sort key for a character sequence. * * @param first beginning of the character sequence. * @param last one-past-the-end of the character sequence. * * Returns a sort key for the character sequence designated by the * iterator range [F1, F2) such that if the character sequence [G1, G2) * sorts before the character sequence [H1, H2) then * v.transform(G1, G2) < v.transform(H1, H2). * * What this really does is provide a more efficient way to compare a * string to multiple other strings in locales with fancy collation * rules and equivalence classes. * * @returns a locale-specific sort key equivalent to the input range. * * @throws std::bad_cast if the current locale does not have a collate * facet. */ template string_type transform(_Fwd_iter __first, _Fwd_iter __last) const { using std::collate; using std::use_facet; const collate<_Ch_type>& __c(use_facet< collate<_Ch_type> >(_M_locale)); string_type __s(__first, __last); return __c.transform(__s.data(), __s.data() + __s.size()); } /** * @brief Dunno. * * @param first beginning of the character sequence. * @param last one-past-the-end of the character sequence. * * Effects: if typeid(use_facet >) == * typeid(collate_byname<_Ch_type>) and the form of the sort key * returned by collate_byname<_Ch_type>::transform(first, last) is known * and can be converted into a primary sort key then returns that key, * otherwise returns an empty string. WTF?? * * @todo Implement this function. */ template string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const; /** * @brief Gets a collation element by name. * * @param first beginning of the collation element name. * @param last one-past-the-end of the collation element name. * * @returns a sequence of one or more characters that represents the * collating element consisting of the character sequence designated by * the iterator range [first, last). Returns an empty string if the * character sequence is not a valid collating element. * * @todo Implement this function. */ template string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const; /** * @brief Maps one or more characters to a named character * classification. * * @param first beginning of the character sequence. * @param last one-past-the-end of the character sequence. * * @returns an unspecified value that represents the character * classification named by the character sequence designated by the * iterator range [first, last). The value returned shall be independent * of the case of the characters in the character sequence. If the name * is not recognized then returns a value that compares equal to 0. * * At least the following names (or their wide-character equivalent) are * supported. * - d * - w * - s * - alnum * - alpha * - blank * - cntrl * - digit * - graph * - lower * - print * - punct * - space * - upper * - xdigit * * @todo Implement this function. */ template char_class_type lookup_classname(_Fwd_iter __first, _Fwd_iter __last) const; /** * @brief Determines if @p c is a member of an identified class. * * @param c a character. * @param f a class type (as returned from lookup_classname). * * @returns true if the character @p c is a member of the classification * represented by @p f, false otherwise. * * @throws std::bad_cast if the current locale does not have a ctype * facet. */ bool isctype(_Ch_type __c, char_class_type __f) const; /** * @brief Converts a digit to an int. * * @param ch a character representing a digit. * @param radix the radix if the numeric conversion (limited to 8, 10, * or 16). * * @returns the value represented by the digit ch in base radix if the * character ch is a valid digit in base radix; otherwise returns -1. */ int value(_Ch_type __ch, int __radix) const; /** * @brief Imbues the regex_traits object with a copy of a new locale. * * @param loc A locale. * * @returns a copy of the previous locale in use by the regex_traits * object. * * @note Calling imbue with a different locale than the one currently in * use invalidates all cached data held by *this. */ locale_type imbue(locale_type __loc) { std::swap(_M_locale, __loc); return __loc; } /** * @brief Gets a copy of the current locale in use by the regex_traits * object. */ locale_type getloc() const { return _M_locale; } protected: locale_type _M_locale; }; template bool regex_traits<_Ch_type>:: isctype(_Ch_type __c, char_class_type __f) const { using std::ctype; using std::use_facet; const ctype<_Ch_type>& __ctype(use_facet< ctype<_Ch_type> >(_M_locale)); if (__ctype.is(__c, __f)) return true; #if 0 // special case of underscore in [[:w:]] if (__c == __ctype.widen('_')) { const char* const __wb[] = "w"; char_class_type __wt = this->lookup_classname(__wb, __wb + sizeof(__wb)); if (__f | __wt) return true; } // special case of [[:space:]] in [[:blank:]] if (__c == __ctype.isspace(__c)) { const char* const __bb[] = "blank"; char_class_type __bt = this->lookup_classname(__bb, __bb + sizeof(__bb)); if (__f | __bt) return true; } #endif return false; } template int regex_traits<_Ch_type>:: value(_Ch_type __ch, int __radix) const { std::basic_istringstream<_Ch_type> __is(string_type(1, __ch)); int __v; if (__radix == 8) __is >> std::oct; else if (__radix == 16) __is >> std::hex; __is >> __v; return __is.fail() ? -1 : __v; } // [7.8] Class basic_regex /** * Objects of specializations of this class represent regular expressions * constructed from sequences of character type @p _Ch_type. * * Storage for the regular expression is allocated and deallocated as * necessary by the member functions of this class. */ template > class basic_regex { public: // types: typedef _Ch_type value_type; typedef regex_constants::syntax_option_type flag_type; typedef typename _Rx_traits::locale_type locale_type; typedef typename _Rx_traits::string_type string_type; /** * @name Constants * tr1 [7.8.1] std [28.8.1] */ //@{ static const regex_constants::syntax_option_type icase = regex_constants::icase; static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs; static const regex_constants::syntax_option_type optimize = regex_constants::optimize; static const regex_constants::syntax_option_type collate = regex_constants::collate; static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript; static const regex_constants::syntax_option_type basic = regex_constants::basic; static const regex_constants::syntax_option_type extended = regex_constants::extended; static const regex_constants::syntax_option_type awk = regex_constants::awk; static const regex_constants::syntax_option_type grep = regex_constants::grep; static const regex_constants::syntax_option_type egrep = regex_constants::egrep; //@} // [7.8.2] construct/copy/destroy /** * Constructs a basic regular expression that does not match any * character sequence. */ basic_regex() : _M_flags(regex_constants::ECMAScript), _M_pattern(), _M_mark_count(0) { _M_compile(); } /** * @brief Constructs a basic regular expression from the sequence * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the * flags in @p f. * * @param p A pointer to the start of a C-style null-terminated string * containing a regular expression. * @param f Flags indicating the syntax rules and options. * * @throws regex_error if @p p is not a valid regular expression. */ explicit basic_regex(const _Ch_type* __p, flag_type __f = regex_constants::ECMAScript) : _M_flags(__f), _M_pattern(__p), _M_mark_count(0) { _M_compile(); } /** * @brief Constructs a basic regular expression from the sequence * [p, p + len) interpreted according to the flags in @p f. * * @param p A pointer to the start of a string containing a regular * expression. * @param len The length of the string containing the regular expression. * @param f Flags indicating the syntax rules and options. * * @throws regex_error if @p p is not a valid regular expression. */ basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f) : _M_flags(__f) , _M_pattern(__p, __len), _M_mark_count(0) { _M_compile(); } /** * @brief Copy-constructs a basic regular expression. * * @param rhs A @p regex object. */ basic_regex(const basic_regex& __rhs) : _M_flags(__rhs._M_flags), _M_pattern(__rhs._M_pattern), _M_mark_count(__rhs._M_mark_count) { _M_compile(); } /** * @brief Constructs a basic regular expression from the string * @p s interpreted according to the flags in @p f. * * @param s A string containing a regular expression. * @param f Flags indicating the syntax rules and options. * * @throws regex_error if @p s is not a valid regular expression. */ template explicit basic_regex(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, flag_type __f = regex_constants::ECMAScript) : _M_flags(__f), _M_pattern(__s.begin(), __s.end()), _M_mark_count(0) { _M_compile(); } /** * @brief Constructs a basic regular expression from the range * [first, last) interpreted according to the flags in @p f. * * @param first The start of a range containing a valid regular * expression. * @param last The end of a range containing a valid regular * expression. * @param f The format flags of the regular expression. * * @throws regex_error if @p [first, last) is not a valid regular * expression. */ template basic_regex(_InputIterator __first, _InputIterator __last, flag_type __f = regex_constants::ECMAScript) : _M_flags(__f), _M_pattern(__first, __last), _M_mark_count(0) { _M_compile(); } #ifdef _GLIBCXX_INCLUDE_AS_CXX11 /** * @brief Constructs a basic regular expression from an initializer list. * * @param l The initializer list. * @param f The format flags of the regular expression. * * @throws regex_error if @p l is not a valid regular expression. */ basic_regex(initializer_list<_Ch_type> __l, flag_type __f = regex_constants::ECMAScript) : _M_flags(__f), _M_pattern(__l.begin(), __l.end()), _M_mark_count(0) { _M_compile(); } #endif /** * @brief Destroys a basic regular expression. */ ~basic_regex() { } /** * @brief Assigns one regular expression to another. */ basic_regex& operator=(const basic_regex& __rhs) { return this->assign(__rhs); } /** * @brief Replaces a regular expression with a new one constructed from * a C-style null-terminated string. * * @param A pointer to the start of a null-terminated C-style string * containing a regular expression. */ basic_regex& operator=(const _Ch_type* __p) { return this->assign(__p, flags()); } /** * @brief Replaces a regular expression with a new one constructed from * a string. * * @param A pointer to a string containing a regular expression. */ template basic_regex& operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s) { return this->assign(__s, flags()); } // [7.8.3] assign /** * @brief the real assignment operator. * * @param that Another regular expression object. */ basic_regex& assign(const basic_regex& __that) { basic_regex __tmp(__that); this->swap(__tmp); return *this; } /** * @brief Assigns a new regular expression to a regex object from a * C-style null-terminated string containing a regular expression * pattern. * * @param p A pointer to a C-style null-terminated string containing * a regular expression pattern. * @param flags Syntax option flags. * * @throws regex_error if p does not contain a valid regular expression * pattern interpreted according to @p flags. If regex_error is thrown, * *this remains unchanged. */ basic_regex& assign(const _Ch_type* __p, flag_type __flags = regex_constants::ECMAScript) { return this->assign(string_type(__p), __flags); } /** * @brief Assigns a new regular expression to a regex object from a * C-style string containing a regular expression pattern. * * @param p A pointer to a C-style string containing a * regular expression pattern. * @param len The length of the regular expression pattern string. * @param flags Syntax option flags. * * @throws regex_error if p does not contain a valid regular expression * pattern interpreted according to @p flags. If regex_error is thrown, * *this remains unchanged. */ basic_regex& assign(const _Ch_type* __p, std::size_t __len, flag_type __flags) { return this->assign(string_type(__p, __len), __flags); } /** * @brief Assigns a new regular expression to a regex object from a * string containing a regular expression pattern. * * @param s A string containing a regular expression pattern. * @param flags Syntax option flags. * * @throws regex_error if p does not contain a valid regular expression * pattern interpreted according to @p flags. If regex_error is thrown, * *this remains unchanged. */ template basic_regex& assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s, flag_type __f = regex_constants::ECMAScript) { basic_regex __tmp(__s, __f); this->swap(__tmp); return *this; } /** * @brief Assigns a new regular expression to a regex object. * * @param first The start of a range containing a valid regular * expression. * @param last The end of a range containing a valid regular * expression. * @param flags Syntax option flags. * * @throws regex_error if p does not contain a valid regular expression * pattern interpreted according to @p flags. If regex_error is thrown, * the object remains unchanged. */ template basic_regex& assign(_InputIterator __first, _InputIterator __last, flag_type __flags = regex_constants::ECMAScript) { return this->assign(string_type(__first, __last), __flags); } #ifdef _GLIBCXX_INCLUDE_AS_CXX11 /** * @brief Assigns a new regular expression to a regex object. * * @param l An initializer list representing a regular expression. * @param flags Syntax option flags. * * @throws regex_error if @p l does not contain a valid regular * expression pattern interpreted according to @p flags. If regex_error * is thrown, the object remains unchanged. */ basic_regex& assign(initializer_list<_Ch_type> __l, flag_type __f = regex_constants::ECMAScript) { return this->assign(__l.begin(), __l.end(), __f); } #endif // [7.8.4] const operations /** * @brief Gets the number of marked subexpressions within the regular * expression. */ unsigned int mark_count() const { return _M_mark_count; } /** * @brief Gets the flags used to construct the regular expression * or in the last call to assign(). */ flag_type flags() const { return _M_flags; } // [7.8.5] locale /** * @brief Imbues the regular expression object with the given locale. * * @param loc A locale. */ locale_type imbue(locale_type __loc) { return _M_traits.imbue(__loc); } /** * @brief Gets the locale currently imbued in the regular expression * object. */ locale_type getloc() const { return _M_traits.getloc(); } // [7.8.6] swap /** * @brief Swaps the contents of two regular expression objects. * * @param rhs Another regular expression object. */ void swap(basic_regex& __rhs) { std::swap(_M_flags, __rhs._M_flags); std::swap(_M_pattern, __rhs._M_pattern); std::swap(_M_mark_count, __rhs._M_mark_count); std::swap(_M_traits, __rhs._M_traits); } private: /** * @brief Compiles a regular expression pattern into a NFA. * @todo Implement this function. */ void _M_compile(); protected: flag_type _M_flags; string_type _M_pattern; unsigned int _M_mark_count; _Rx_traits _M_traits; }; /** @brief Standard regular expressions. */ typedef basic_regex regex; #ifdef _GLIBCXX_USE_WCHAR_T /** @brief Standard wide-character regular expressions. */ typedef basic_regex wregex; #endif // [7.8.6] basic_regex swap /** * @brief Swaps the contents of two regular expression objects. * @param lhs First regular expression. * @param rhs Second regular expression. */ template inline void swap(basic_regex<_Ch_type, _Rx_traits>& __lhs, basic_regex<_Ch_type, _Rx_traits>& __rhs) { __lhs.swap(__rhs); } // [7.9] Class template sub_match /** * A sequence of characters matched by a particular marked sub-expression. * * An object of this class is essentially a pair of iterators marking a * matched subexpression within a regular expression pattern match. Such * objects can be converted to and compared with std::basic_string objects * of a similar base character type as the pattern matched by the regular * expression. * * The iterators that make up the pair are the usual half-open interval * referencing the actual original pattern matched. */ template class sub_match : public std::pair<_BiIter, _BiIter> { public: typedef typename iterator_traits<_BiIter>::value_type value_type; typedef typename iterator_traits<_BiIter>::difference_type difference_type; typedef _BiIter iterator; public: bool matched; /** * Gets the length of the matching sequence. */ difference_type length() const { return this->matched ? std::distance(this->first, this->second) : 0; } /** * @brief Gets the matching sequence as a string. * * @returns the matching sequence as a string. * * This is the implicit conversion operator. It is identical to the * str() member function except that it will want to pop up in * unexpected places and cause a great deal of confusion and cursing * from the unwary. */ operator basic_string() const { return this->matched ? std::basic_string(this->first, this->second) : std::basic_string(); } /** * @brief Gets the matching sequence as a string. * * @returns the matching sequence as a string. */ basic_string str() const { return this->matched ? std::basic_string(this->first, this->second) : std::basic_string(); } /** * @brief Compares this and another matched sequence. * * @param s Another matched sequence to compare to this one. * * @retval <0 this matched sequence will collate before @p s. * @retval =0 this matched sequence is equivalent to @p s. * @retval <0 this matched sequence will collate after @p s. */ int compare(const sub_match& __s) const { return this->str().compare(__s.str()); } /** * @brief Compares this sub_match to a string. * * @param s A string to compare to this sub_match. * * @retval <0 this matched sequence will collate before @p s. * @retval =0 this matched sequence is equivalent to @p s. * @retval <0 this matched sequence will collate after @p s. */ int compare(const basic_string& __s) const { return this->str().compare(__s); } /** * @brief Compares this sub_match to a C-style string. * * @param s A C-style string to compare to this sub_match. * * @retval <0 this matched sequence will collate before @p s. * @retval =0 this matched sequence is equivalent to @p s. * @retval <0 this matched sequence will collate after @p s. */ int compare(const value_type* __s) const { return this->str().compare(__s); } }; /** @brief Standard regex submatch over a C-style null-terminated string. */ typedef sub_match csub_match; /** @brief Standard regex submatch over a standard string. */ typedef sub_match ssub_match; #ifdef _GLIBCXX_USE_WCHAR_T /** @brief Regex submatch over a C-style null-terminated wide string. */ typedef sub_match wcsub_match; /** @brief Regex submatch over a standard wide string. */ typedef sub_match wssub_match; #endif // [7.9.2] sub_match non-member operators /** * @brief Tests the equivalence of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) == 0; } /** * @brief Tests the inequivalence of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) != 0; } /** * @brief Tests the ordering of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) < 0; } /** * @brief Tests the ordering of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) <= 0; } /** * @brief Tests the ordering of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) >= 0; } /** * @brief Tests the ordering of two regular expression submatches. * @param lhs First regular expression submatch. * @param rhs Second regular expression submatch. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) > 0; } /** * @brief Tests the equivalence of a string and a regular expression * submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs == __rhs.str(); } /** * @brief Tests the inequivalence of a string and a regular expression * submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs != __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs < __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs > __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs >= __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs <= __rhs.str(); } /** * @brief Tests the equivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() == __rhs; } /** * @brief Tests the inequivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() != __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() < __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() > __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() >= __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(const sub_match<_Bi_iter>& __lhs, const basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs.str() <= __rhs; } /** * @brief Tests the equivalence of a C string and a regular expression * submatch. * @param lhs A C string. * @param rhs A regular expression submatch. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs == __rhs.str(); } /** * @brief Tests the inequivalence of an iterator value and a regular * expression submatch. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs != __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs < __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs > __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs >= __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs <= __rhs.str(); } /** * @brief Tests the equivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A pointer to a string? * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() == __rhs; } /** * @brief Tests the inequivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A pointer to a string. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() != __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() < __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() > __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() >= __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A string. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.str() <= __rhs; } /** * @brief Tests the equivalence of a string and a regular expression * submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs == __rhs.str(); } /** * @brief Tests the inequivalence of a string and a regular expression * submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs != __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs < __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs > __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs >= __rhs.str(); } /** * @brief Tests the ordering of a string and a regular expression submatch. * @param lhs A string. * @param rhs A regular expression submatch. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, const sub_match<_Bi_iter>& __rhs) { return __lhs <= __rhs.str(); } /** * @brief Tests the equivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs is equivalent to @a rhs, false otherwise. */ template inline bool operator==(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() == __rhs; } /** * @brief Tests the inequivalence of a regular expression submatch and a * string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. */ template inline bool operator!=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() != __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs precedes @a rhs, false otherwise. */ template inline bool operator<(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() < __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs succeeds @a rhs, false otherwise. */ template inline bool operator>(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() > __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs does not precede @a rhs, false otherwise. */ template inline bool operator>=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() >= __rhs; } /** * @brief Tests the ordering of a regular expression submatch and a string. * @param lhs A regular expression submatch. * @param rhs A const string reference. * @returns true if @a lhs does not succeed @a rhs, false otherwise. */ template inline bool operator<=(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs.str() <= __rhs; } /** * @brief Inserts a matched string into an output stream. * * @param os The output stream. * @param m A submatch string. * * @returns the output stream with the submatch string inserted. */ template inline basic_ostream<_Ch_type, _Ch_traits>& operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os, const sub_match<_Bi_iter>& __m) { return __os << __m.str(); } // [7.10] Class template match_results /** * @brief The results of a match or search operation. * * A collection of character sequences representing the result of a regular * expression match. Storage for the collection is allocated and freed as * necessary by the member functions of class template match_results. * * This class satisfies the Sequence requirements, with the exception that * only the operations defined for a const-qualified Sequence are supported. * * The sub_match object stored at index 0 represents sub-expression 0, i.e. * the whole match. In this case the sub_match member matched is always true. * The sub_match object stored at index n denotes what matched the marked * sub-expression n within the matched expression. If the sub-expression n * participated in a regular expression match then the sub_match member * matched evaluates to true, and members first and second denote the range * of characters [first, second) which formed that match. Otherwise matched * is false, and members first and second point to the end of the sequence * that was searched. * * @nosubgrouping */ template > > class match_results : private std::vector, _Allocator> { private: typedef std::vector, _Allocator> _Base_type; public: /** * @name 10.? Public Types */ //@{ typedef sub_match<_Bi_iter> value_type; typedef typename _Allocator::const_reference const_reference; typedef const_reference reference; typedef typename _Base_type::const_iterator const_iterator; typedef const_iterator iterator; typedef typename iterator_traits<_Bi_iter>::difference_type difference_type; typedef typename _Allocator::size_type size_type; typedef _Allocator allocator_type; typedef typename iterator_traits<_Bi_iter>::value_type char_type; typedef basic_string string_type; //@} public: /** * @name 10.1 Construction, Copying, and Destruction */ //@{ /** * @brief Constructs a default %match_results container. * @post size() returns 0 and str() returns an empty string. */ explicit match_results(const _Allocator& __a = _Allocator()) : _Base_type(__a), _M_matched(false) { } /** * @brief Copy constructs a %match_results. */ match_results(const match_results& __rhs) : _Base_type(__rhs), _M_matched(__rhs._M_matched), _M_prefix(__rhs._M_prefix), _M_suffix(__rhs._M_suffix) { } /** * @brief Assigns rhs to *this. */ match_results& operator=(const match_results& __rhs) { match_results __tmp(__rhs); this->swap(__tmp); return *this; } /** * @brief Destroys a %match_results object. */ ~match_results() { } //@} /** * @name 10.2 Size */ //@{ /** * @brief Gets the number of matches and submatches. * * The number of matches for a given regular expression will be either 0 * if there was no match or mark_count() + 1 if a match was successful. * Some matches may be empty. * * @returns the number of matches found. */ size_type size() const { return _M_matched ? _Base_type::size() + 1 : 0; } //size_type //max_size() const; using _Base_type::max_size; /** * @brief Indicates if the %match_results contains no results. * @retval true The %match_results object is empty. * @retval false The %match_results object is not empty. */ bool empty() const { return size() == 0; } //@} /** * @name 10.3 Element Access */ //@{ /** * @brief Gets the length of the indicated submatch. * @param sub indicates the submatch. * * This function returns the length of the indicated submatch, or the * length of the entire match if @p sub is zero (the default). */ difference_type length(size_type __sub = 0) const { return _M_matched ? this->str(__sub).length() : 0; } /** * @brief Gets the offset of the beginning of the indicated submatch. * @param sub indicates the submatch. * * This function returns the offset from the beginning of the target * sequence to the beginning of the submatch, unless the value of @p sub * is zero (the default), in which case this function returns the offset * from the beginning of the target sequence to the beginning of the * match. */ difference_type position(size_type __sub = 0) const { return _M_matched ? std::distance(this->prefix().first, (*this)[__sub].first) : 0; } /** * @brief Gets the match or submatch converted to a string type. * @param sub indicates the submatch. * * This function gets the submatch (or match, if @p sub is zero) extracted * from the target range and converted to the associated string type. */ string_type str(size_type __sub = 0) const { return _M_matched ? (*this)[__sub].str() : string_type(); } /** * @brief Gets a %sub_match reference for the match or submatch. * @param sub indicates the submatch. * * This function gets a reference to the indicated submatch, or the entire * match if @p sub is zero. * * If @p sub >= size() then this function returns a %sub_match with a * special value indicating no submatch. */ const_reference operator[](size_type __sub) const { return _Base_type::operator[](__sub); } /** * @brief Gets a %sub_match representing the match prefix. * * This function gets a reference to a %sub_match object representing the * part of the target range between the start of the target range and the * start of the match. */ const_reference prefix() const { return _M_prefix; } /** * @brief Gets a %sub_match representing the match suffix. * * This function gets a reference to a %sub_match object representing the * part of the target range between the end of the match and the end of * the target range. */ const_reference suffix() const { return _M_suffix; } /** * @brief Gets an iterator to the start of the %sub_match collection. */ const_iterator begin() const { return _Base_type::begin(); } #ifdef _GLIBCXX_INCLUDE_AS_CXX11 /** * @brief Gets an iterator to the start of the %sub_match collection. */ const_iterator cbegin() const { return _Base_type::begin(); } #endif /** * @brief Gets an iterator to one-past-the-end of the collection. */ const_iterator end() const { return _Base_type::end(); } #ifdef _GLIBCXX_INCLUDE_AS_CXX11 /** * @brief Gets an iterator to one-past-the-end of the collection. */ const_iterator cend() const { return _Base_type::end(); } #endif //@} /** * @name 10.4 Formatting * * These functions perform formatted substitution of the matched * character sequences into their target. The format specifiers * and escape sequences accepted by these functions are * determined by their @p flags parameter as documented above. */ //@{ /** * @todo Implement this function. */ template _Out_iter format(_Out_iter __out, const string_type& __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const; /** * @todo Implement this function. */ string_type format(const string_type& __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const; //@} /** * @name 10.5 Allocator */ //@{ /** * @brief Gets a copy of the allocator. */ //allocator_type //get_allocator() const; using _Base_type::get_allocator; //@} /** * @name 10.6 Swap */ //@{ /** * @brief Swaps the contents of two match_results. */ void swap(match_results& __that) { _Base_type::swap(__that); std::swap(_M_matched, __that._M_matched); std::swap(_M_prefix, __that._M_prefix); std::swap(_M_suffix, __that._M_suffix); } //@} private: bool _M_matched; value_type _M_prefix; value_type _M_suffix; }; typedef match_results cmatch; typedef match_results smatch; #ifdef _GLIBCXX_USE_WCHAR_T typedef match_results wcmatch; typedef match_results wsmatch; #endif // match_results comparisons /** * @brief Compares two match_results for equality. * @returns true if the two objects refer to the same match, * false otherwise. * @todo Implement this function. */ template inline bool operator==(const match_results<_Bi_iter, _Allocator>& __m1, const match_results<_Bi_iter, _Allocator>& __m2); /** * @brief Compares two match_results for inequality. * @returns true if the two objects do not refer to the same match, * false otherwise. */ template inline bool operator!=(const match_results<_Bi_iter, _Allocator>& __m1, const match_results<_Bi_iter, _Allocator>& __m2) { return !(__m1 == __m2); } // [7.10.6] match_results swap /** * @brief Swaps two match results. * @param lhs A match result. * @param rhs A match result. * * The contents of the two match_results objects are swapped. */ template inline void swap(match_results<_Bi_iter, _Allocator>& __lhs, match_results<_Bi_iter, _Allocator>& __rhs) { __lhs.swap(__rhs); } // [7.11.2] Function template regex_match /** * @name Matching, Searching, and Replacing */ //@{ /** * @brief Determines if there is a match between the regular expression @p e * and all of the character sequence [first, last). * * @param first Beginning of the character sequence to match. * @param last One-past-the-end of the character sequence to match. * @param m The match results. * @param re The regular expression. * @param flags Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. * * @todo Implement this function. */ template bool regex_match(_Bi_iter __first, _Bi_iter __last, match_results<_Bi_iter, _Allocator>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default); /** * @brief Indicates if there is a match between the regular expression @p e * and all of the character sequence [first, last). * * @param first Beginning of the character sequence to match. * @param last One-past-the-end of the character sequence to match. * @param re The regular expression. * @param flags Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. */ template bool regex_match(_Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results<_Bi_iter> __what; return regex_match(__first, __last, __what, __re, __flags); } /** * @brief Determines if there is a match between the regular expression @p e * and a C-style null-terminated string. * * @param s The C-style null-terminated string to match. * @param m The match results. * @param re The regular expression. * @param f Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. */ template inline bool regex_match(const _Ch_type* __s, match_results& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); } /** * @brief Determines if there is a match between the regular expression @p e * and a string. * * @param s The string to match. * @param m The match results. * @param re The regular expression. * @param flags Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. */ template inline bool regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, match_results::const_iterator, _Allocator>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); } /** * @brief Indicates if there is a match between the regular expression @p e * and a C-style null-terminated string. * * @param s The C-style null-terminated string to match. * @param re The regular expression. * @param f Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. */ template inline bool regex_match(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); } /** * @brief Indicates if there is a match between the regular expression @p e * and a string. * * @param s [IN] The string to match. * @param re [IN] The regular expression. * @param flags [IN] Controls how the regular expression is matched. * * @retval true A match exists. * @retval false Otherwise. * * @throws an exception of type regex_error. */ template inline bool regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_match(__s.begin(), __s.end(), __re, __flags); } // [7.11.3] Function template regex_search /** * Searches for a regular expression within a range. * @param first [IN] The start of the string to search. * @param last [IN] One-past-the-end of the string to search. * @param m [OUT] The match results. * @param re [IN] The regular expression to search for. * @param flags [IN] Search policy flags. * @retval true A match was found within the string. * @retval false No match was found within the string, the content of %m is * undefined. * * @throws an exception of type regex_error. * * @todo Implement this function. */ template inline bool regex_search(_Bi_iter __first, _Bi_iter __last, match_results<_Bi_iter, _Allocator>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default); /** * Searches for a regular expression within a range. * @param first [IN] The start of the string to search. * @param last [IN] One-past-the-end of the string to search. * @param re [IN] The regular expression to search for. * @param flags [IN] Search policy flags. * @retval true A match was found within the string. * @retval false No match was found within the string. * @doctodo * * @throws an exception of type regex_error. */ template inline bool regex_search(_Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results<_Bi_iter> __what; return regex_search(__first, __last, __what, __re, __flags); } /** * @brief Searches for a regular expression within a C-string. * @param s [IN] A C-string to search for the regex. * @param m [OUT] The set of regex matches. * @param e [IN] The regex to search for in @p s. * @param f [IN] The search flags. * @retval true A match was found within the string. * @retval false No match was found within the string, the content of %m is * undefined. * @doctodo * * @throws an exception of type regex_error. */ template inline bool regex_search(const _Ch_type* __s, match_results& __m, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); } /** * @brief Searches for a regular expression within a C-string. * @param s [IN] The C-string to search. * @param e [IN] The regular expression to search for. * @param f [IN] Search policy flags. * @retval true A match was found within the string. * @retval false No match was found within the string. * @doctodo * * @throws an exception of type regex_error. */ template inline bool regex_search(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); } /** * @brief Searches for a regular expression within a string. * @param s [IN] The string to search. * @param e [IN] The regular expression to search for. * @param flags [IN] Search policy flags. * @retval true A match was found within the string. * @retval false No match was found within the string. * @doctodo * * @throws an exception of type regex_error. */ template inline bool regex_search(const basic_string<_Ch_type, _Ch_traits, _String_allocator>& __s, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_search(__s.begin(), __s.end(), __e, __flags); } /** * @brief Searches for a regular expression within a string. * @param s [IN] A C++ string to search for the regex. * @param m [OUT] The set of regex matches. * @param e [IN] The regex to search for in @p s. * @param f [IN] The search flags. * @retval true A match was found within the string. * @retval false No match was found within the string, the content of %m is * undefined. * * @throws an exception of type regex_error. */ template inline bool regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, match_results::const_iterator, _Allocator>& __m, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s.begin(), __s.end(), __m, __e, __f); } // tr1 [7.11.4] std [28.11.4] Function template regex_replace /** * @doctodo * @param out * @param first * @param last * @param e * @param fmt * @param flags * * @returns out * @throws an exception of type regex_error. * * @todo Implement this function. */ template inline _Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __e, const basic_string<_Ch_type>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default); /** * @doctodo * @param s * @param e * @param fmt * @param flags * * @returns a copy of string @p s with replacements. * * @throws an exception of type regex_error. */ template inline basic_string<_Ch_type> regex_replace(const basic_string<_Ch_type>& __s, const basic_regex<_Ch_type, _Rx_traits>& __e, const basic_string<_Ch_type>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { std::string __result; regex_replace(std::back_inserter(__result), __s.begin(), __s.end(), __e, __fmt, __flags); return __result; } //@} // tr1 [7.12.1] std [28.12] Class template regex_iterator /** * An iterator adaptor that will provide repeated calls of regex_search over * a range until no more matches remain. */ template::value_type, typename _Rx_traits = regex_traits<_Ch_type> > class regex_iterator { public: typedef basic_regex<_Ch_type, _Rx_traits> regex_type; typedef match_results<_Bi_iter> value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef std::forward_iterator_tag iterator_category; public: /** * @brief Provides a singular iterator, useful for indicating * one-past-the-end of a range. * @todo Implement this function. * @doctodo */ regex_iterator(); /** * Constructs a %regex_iterator... * @param a [IN] The start of a text range to search. * @param b [IN] One-past-the-end of the text range to search. * @param re [IN] The regular expression to match. * @param m [IN] Policy flags for match rules. * @todo Implement this function. * @doctodo */ regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, regex_constants::match_flag_type __m = regex_constants::match_default); /** * Copy constructs a %regex_iterator. * @todo Implement this function. * @doctodo */ regex_iterator(const regex_iterator& __rhs); /** * @todo Implement this function. * @doctodo */ regex_iterator& operator=(const regex_iterator& __rhs); /** * @todo Implement this function. * @doctodo */ bool operator==(const regex_iterator& __rhs); /** * @todo Implement this function. * @doctodo */ bool operator!=(const regex_iterator& __rhs); /** * @todo Implement this function. * @doctodo */ const value_type& operator*(); /** * @todo Implement this function. * @doctodo */ const value_type* operator->(); /** * @todo Implement this function. * @doctodo */ regex_iterator& operator++(); /** * @todo Implement this function. * @doctodo */ regex_iterator operator++(int); private: // these members are shown for exposition only: _Bi_iter begin; _Bi_iter end; const regex_type* pregex; regex_constants::match_flag_type flags; match_results<_Bi_iter> match; }; typedef regex_iterator cregex_iterator; typedef regex_iterator sregex_iterator; #ifdef _GLIBCXX_USE_WCHAR_T typedef regex_iterator wcregex_iterator; typedef regex_iterator wsregex_iterator; #endif // [7.12.2] Class template regex_token_iterator /** * Iterates over submatches in a range (or @a splits a text string). * * The purpose of this iterator is to enumerate all, or all specified, * matches of a regular expression within a text range. The dereferenced * value of an iterator of this class is a std::tr1::sub_match object. */ template::value_type, typename _Rx_traits = regex_traits<_Ch_type> > class regex_token_iterator { public: typedef basic_regex<_Ch_type, _Rx_traits> regex_type; typedef sub_match<_Bi_iter> value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef std::forward_iterator_tag iterator_category; public: /** * @brief Default constructs a %regex_token_iterator. * @todo Implement this function. * * A default-constructed %regex_token_iterator is a singular iterator * that will compare equal to the one-past-the-end value for any * iterator of the same type. */ regex_token_iterator(); /** * Constructs a %regex_token_iterator... * @param a [IN] The start of the text to search. * @param b [IN] One-past-the-end of the text to search. * @param re [IN] The regular expression to search for. * @param submatch [IN] Which submatch to return. There are some * special values for this parameter: * - -1 each enumerated subexpression does NOT * match the regular expression (aka field * splitting) * - 0 the entire string matching the * subexpression is returned for each match * within the text. * - >0 enumerates only the indicated * subexpression from a match within the text. * @param m [IN] Policy flags for match rules. * * @todo Implement this function. * @doctodo */ regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, int __submatch = 0, regex_constants::match_flag_type __m = regex_constants::match_default); /** * Constructs a %regex_token_iterator... * @param a [IN] The start of the text to search. * @param b [IN] One-past-the-end of the text to search. * @param re [IN] The regular expression to search for. * @param submatches [IN] A list of subexpressions to return for each * regular expression match within the text. * @param m [IN] Policy flags for match rules. * * @todo Implement this function. * @doctodo */ regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, const std::vector& __submatches, regex_constants::match_flag_type __m = regex_constants::match_default); /** * Constructs a %regex_token_iterator... * @param a [IN] The start of the text to search. * @param b [IN] One-past-the-end of the text to search. * @param re [IN] The regular expression to search for. * @param submatches [IN] A list of subexpressions to return for each * regular expression match within the text. * @param m [IN] Policy flags for match rules. * @todo Implement this function. * @doctodo */ template regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, const int (&__submatches)[_Nm], regex_constants::match_flag_type __m = regex_constants::match_default); /** * @brief Copy constructs a %regex_token_iterator. * @param rhs [IN] A %regex_token_iterator to copy. * @todo Implement this function. */ regex_token_iterator(const regex_token_iterator& __rhs); /** * @brief Assigns a %regex_token_iterator to another. * @param rhs [IN] A %regex_token_iterator to copy. * @todo Implement this function. */ regex_token_iterator& operator=(const regex_token_iterator& __rhs); /** * @brief Compares a %regex_token_iterator to another for equality. * @todo Implement this function. */ bool operator==(const regex_token_iterator& __rhs); /** * @brief Compares a %regex_token_iterator to another for inequality. * @todo Implement this function. */ bool operator!=(const regex_token_iterator& __rhs); /** * @brief Dereferences a %regex_token_iterator. * @todo Implement this function. */ const value_type& operator*(); /** * @brief Selects a %regex_token_iterator member. * @todo Implement this function. */ const value_type* operator->(); /** * @brief Increments a %regex_token_iterator. * @todo Implement this function. */ regex_token_iterator& operator++(); /** * @brief Postincrements a %regex_token_iterator. * @todo Implement this function. */ regex_token_iterator operator++(int); private: // data members for exposition only: typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator; position_iterator __position; const value_type* __result; value_type __suffix; std::size_t __n; std::vector __subs; }; /** @brief Token iterator for C-style NULL-terminated strings. */ typedef regex_token_iterator cregex_token_iterator; /** @brief Token iterator for standard strings. */ typedef regex_token_iterator sregex_token_iterator; #ifdef _GLIBCXX_USE_WCHAR_T /** @brief Token iterator for C-style NULL-terminated wide strings. */ typedef regex_token_iterator wcregex_token_iterator; /** @brief Token iterator for standard wide-character strings. */ typedef regex_token_iterator wsregex_token_iterator; #endif //@} } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_REGEX c++/8/tr1/hashtable_policy.h000064400000060776152640040210011466 0ustar00// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*- // Copyright (C) 2010-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/hashtable_policy.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. * @headername{tr1/unordered_map, tr1/unordered_set} */ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { namespace __detail { // Helper function: return distance(first, last) for forward // iterators, or 0 for input iterators. template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last, std::input_iterator_tag) { return 0; } template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last, std::forward_iterator_tag) { return std::distance(__first, __last); } template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last) { typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag; return __distance_fw(__first, __last, _Tag()); } // Auxiliary types used for all instantiations of _Hashtable: nodes // and iterators. // Nodes, used to wrap elements stored in the hash table. A policy // template parameter of class template _Hashtable controls whether // nodes also store a hash code. In some cases (e.g. strings) this // may be a performance win. template struct _Hash_node; template struct _Hash_node<_Value, true> { _Value _M_v; std::size_t _M_hash_code; _Hash_node* _M_next; }; template struct _Hash_node<_Value, false> { _Value _M_v; _Hash_node* _M_next; }; // Local iterators, used to iterate within a bucket but not between // buckets. template struct _Node_iterator_base { _Node_iterator_base(_Hash_node<_Value, __cache>* __p) : _M_cur(__p) { } void _M_incr() { _M_cur = _M_cur->_M_next; } _Hash_node<_Value, __cache>* _M_cur; }; template inline bool operator==(const _Node_iterator_base<_Value, __cache>& __x, const _Node_iterator_base<_Value, __cache>& __y) { return __x._M_cur == __y._M_cur; } template inline bool operator!=(const _Node_iterator_base<_Value, __cache>& __x, const _Node_iterator_base<_Value, __cache>& __y) { return __x._M_cur != __y._M_cur; } template struct _Node_iterator : public _Node_iterator_base<_Value, __cache> { typedef _Value value_type; typedef typename __gnu_cxx::__conditional_type<__constant_iterators, const _Value*, _Value*>::__type pointer; typedef typename __gnu_cxx::__conditional_type<__constant_iterators, const _Value&, _Value&>::__type reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Node_iterator() : _Node_iterator_base<_Value, __cache>(0) { } explicit _Node_iterator(_Hash_node<_Value, __cache>* __p) : _Node_iterator_base<_Value, __cache>(__p) { } reference operator*() const { return this->_M_cur->_M_v; } pointer operator->() const { return std::__addressof(this->_M_cur->_M_v); } _Node_iterator& operator++() { this->_M_incr(); return *this; } _Node_iterator operator++(int) { _Node_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Node_const_iterator : public _Node_iterator_base<_Value, __cache> { typedef _Value value_type; typedef const _Value* pointer; typedef const _Value& reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Node_const_iterator() : _Node_iterator_base<_Value, __cache>(0) { } explicit _Node_const_iterator(_Hash_node<_Value, __cache>* __p) : _Node_iterator_base<_Value, __cache>(__p) { } _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, __cache>& __x) : _Node_iterator_base<_Value, __cache>(__x._M_cur) { } reference operator*() const { return this->_M_cur->_M_v; } pointer operator->() const { return std::__addressof(this->_M_cur->_M_v); } _Node_const_iterator& operator++() { this->_M_incr(); return *this; } _Node_const_iterator operator++(int) { _Node_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Hashtable_iterator_base { _Hashtable_iterator_base(_Hash_node<_Value, __cache>* __node, _Hash_node<_Value, __cache>** __bucket) : _M_cur_node(__node), _M_cur_bucket(__bucket) { } void _M_incr() { _M_cur_node = _M_cur_node->_M_next; if (!_M_cur_node) _M_incr_bucket(); } void _M_incr_bucket(); _Hash_node<_Value, __cache>* _M_cur_node; _Hash_node<_Value, __cache>** _M_cur_bucket; }; // Global iterators, used for arbitrary iteration within a hash // table. Larger and more expensive than local iterators. template void _Hashtable_iterator_base<_Value, __cache>:: _M_incr_bucket() { ++_M_cur_bucket; // This loop requires the bucket array to have a non-null sentinel. while (!*_M_cur_bucket) ++_M_cur_bucket; _M_cur_node = *_M_cur_bucket; } template inline bool operator==(const _Hashtable_iterator_base<_Value, __cache>& __x, const _Hashtable_iterator_base<_Value, __cache>& __y) { return __x._M_cur_node == __y._M_cur_node; } template inline bool operator!=(const _Hashtable_iterator_base<_Value, __cache>& __x, const _Hashtable_iterator_base<_Value, __cache>& __y) { return __x._M_cur_node != __y._M_cur_node; } template struct _Hashtable_iterator : public _Hashtable_iterator_base<_Value, __cache> { typedef _Value value_type; typedef typename __gnu_cxx::__conditional_type<__constant_iterators, const _Value*, _Value*>::__type pointer; typedef typename __gnu_cxx::__conditional_type<__constant_iterators, const _Value&, _Value&>::__type reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Hashtable_iterator() : _Hashtable_iterator_base<_Value, __cache>(0, 0) { } _Hashtable_iterator(_Hash_node<_Value, __cache>* __p, _Hash_node<_Value, __cache>** __b) : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { } explicit _Hashtable_iterator(_Hash_node<_Value, __cache>** __b) : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { } reference operator*() const { return this->_M_cur_node->_M_v; } pointer operator->() const { return std::__addressof(this->_M_cur_node->_M_v); } _Hashtable_iterator& operator++() { this->_M_incr(); return *this; } _Hashtable_iterator operator++(int) { _Hashtable_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Hashtable_const_iterator : public _Hashtable_iterator_base<_Value, __cache> { typedef _Value value_type; typedef const _Value* pointer; typedef const _Value& reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Hashtable_const_iterator() : _Hashtable_iterator_base<_Value, __cache>(0, 0) { } _Hashtable_const_iterator(_Hash_node<_Value, __cache>* __p, _Hash_node<_Value, __cache>** __b) : _Hashtable_iterator_base<_Value, __cache>(__p, __b) { } explicit _Hashtable_const_iterator(_Hash_node<_Value, __cache>** __b) : _Hashtable_iterator_base<_Value, __cache>(*__b, __b) { } _Hashtable_const_iterator(const _Hashtable_iterator<_Value, __constant_iterators, __cache>& __x) : _Hashtable_iterator_base<_Value, __cache>(__x._M_cur_node, __x._M_cur_bucket) { } reference operator*() const { return this->_M_cur_node->_M_v; } pointer operator->() const { return std::__addressof(this->_M_cur_node->_M_v); } _Hashtable_const_iterator& operator++() { this->_M_incr(); return *this; } _Hashtable_const_iterator operator++(int) { _Hashtable_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; // Many of class template _Hashtable's template parameters are policy // classes. These are defaults for the policies. // Default range hashing function: use division to fold a large number // into the range [0, N). struct _Mod_range_hashing { typedef std::size_t first_argument_type; typedef std::size_t second_argument_type; typedef std::size_t result_type; result_type operator()(first_argument_type __num, second_argument_type __den) const { return __num % __den; } }; // Default ranged hash function H. In principle it should be a // function object composed from objects of type H1 and H2 such that // h(k, N) = h2(h1(k), N), but that would mean making extra copies of // h1 and h2. So instead we'll just use a tag to tell class template // hashtable to do that composition. struct _Default_ranged_hash { }; // Default value for rehash policy. Bucket size is (usually) the // smallest prime that keeps the load factor small enough. struct _Prime_rehash_policy { _Prime_rehash_policy(float __z = 1.0) : _M_max_load_factor(__z), _M_growth_factor(2.f), _M_next_resize(0) { } float max_load_factor() const { return _M_max_load_factor; } // Return a bucket size no smaller than n. std::size_t _M_next_bkt(std::size_t __n) const; // Return a bucket count appropriate for n elements std::size_t _M_bkt_for_elements(std::size_t __n) const; // __n_bkt is current bucket count, __n_elt is current element count, // and __n_ins is number of elements to be inserted. Do we need to // increase bucket count? If so, return make_pair(true, n), where n // is the new bucket count. If not, return make_pair(false, 0). std::pair _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, std::size_t __n_ins) const; enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 }; float _M_max_load_factor; float _M_growth_factor; mutable std::size_t _M_next_resize; }; extern const unsigned long __prime_list[]; // XXX This is a hack. There's no good reason for any of // _Prime_rehash_policy's member functions to be inline. // Return a prime no smaller than n. inline std::size_t _Prime_rehash_policy:: _M_next_bkt(std::size_t __n) const { // Don't include the last prime in the search, so that anything // higher than the second-to-last prime returns a past-the-end // iterator that can be dereferenced to get the last prime. const unsigned long* __p = std::lower_bound(__prime_list, __prime_list + _S_n_primes - 1, __n); _M_next_resize = static_cast(__builtin_ceil(*__p * _M_max_load_factor)); return *__p; } // Return the smallest prime p such that alpha p >= n, where alpha // is the load factor. inline std::size_t _Prime_rehash_policy:: _M_bkt_for_elements(std::size_t __n) const { const float __min_bkts = __n / _M_max_load_factor; return _M_next_bkt(__builtin_ceil(__min_bkts)); } // Finds the smallest prime p such that alpha p > __n_elt + __n_ins. // If p > __n_bkt, return make_pair(true, p); otherwise return // make_pair(false, 0). In principle this isn't very different from // _M_bkt_for_elements. // The only tricky part is that we're caching the element count at // which we need to rehash, so we don't have to do a floating-point // multiply for every insertion. inline std::pair _Prime_rehash_policy:: _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, std::size_t __n_ins) const { if (__n_elt + __n_ins > _M_next_resize) { float __min_bkts = ((float(__n_ins) + float(__n_elt)) / _M_max_load_factor); if (__min_bkts > __n_bkt) { __min_bkts = std::max(__min_bkts, _M_growth_factor * __n_bkt); return std::make_pair(true, _M_next_bkt(__builtin_ceil(__min_bkts))); } else { _M_next_resize = static_cast (__builtin_ceil(__n_bkt * _M_max_load_factor)); return std::make_pair(false, 0); } } else return std::make_pair(false, 0); } // Base classes for std::tr1::_Hashtable. We define these base // classes because in some cases we want to do different things // depending on the value of a policy class. In some cases the // policy class affects which member functions and nested typedefs // are defined; we handle that by specializing base class templates. // Several of the base class templates need to access other members // of class template _Hashtable, so we use the "curiously recurring // template pattern" for them. // class template _Map_base. If the hashtable has a value type of the // form pair and a key extraction policy that returns the // first part of the pair, the hashtable gets a mapped_type typedef. // If it satisfies those criteria and also has unique keys, then it // also gets an operator[]. template struct _Map_base { }; template struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, false, _Hashtable> { typedef typename _Pair::second_type mapped_type; }; template struct _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable> { typedef typename _Pair::second_type mapped_type; mapped_type& operator[](const _Key& __k); }; template typename _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>::mapped_type& _Map_base<_Key, _Pair, std::_Select1st<_Pair>, true, _Hashtable>:: operator[](const _Key& __k) { _Hashtable* __h = static_cast<_Hashtable*>(this); typename _Hashtable::_Hash_code_type __code = __h->_M_hash_code(__k); std::size_t __n = __h->_M_bucket_index(__k, __code, __h->_M_bucket_count); typename _Hashtable::_Node* __p = __h->_M_find_node(__h->_M_buckets[__n], __k, __code); if (!__p) return __h->_M_insert_bucket(std::make_pair(__k, mapped_type()), __n, __code)->second; return (__p->_M_v).second; } // class template _Rehash_base. Give hashtable the max_load_factor // functions iff the rehash policy is _Prime_rehash_policy. template struct _Rehash_base { }; template struct _Rehash_base<_Prime_rehash_policy, _Hashtable> { float max_load_factor() const { const _Hashtable* __this = static_cast(this); return __this->__rehash_policy().max_load_factor(); } void max_load_factor(float __z) { _Hashtable* __this = static_cast<_Hashtable*>(this); __this->__rehash_policy(_Prime_rehash_policy(__z)); } }; // Class template _Hash_code_base. Encapsulates two policy issues that // aren't quite orthogonal. // (1) the difference between using a ranged hash function and using // the combination of a hash function and a range-hashing function. // In the former case we don't have such things as hash codes, so // we have a dummy type as placeholder. // (2) Whether or not we cache hash codes. Caching hash codes is // meaningless if we have a ranged hash function. // We also put the key extraction and equality comparison function // objects here, for convenience. // Primary template: unused except as a hook for specializations. template struct _Hash_code_base; // Specialization: ranged hash function, no caching hash codes. H1 // and H2 are provided but ignored. We define a dummy hash code type. template struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, false> { protected: _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq, const _H1&, const _H2&, const _Hash& __h) : _M_extract(__ex), _M_eq(__eq), _M_ranged_hash(__h) { } typedef void* _Hash_code_type; _Hash_code_type _M_hash_code(const _Key& __key) const { return 0; } std::size_t _M_bucket_index(const _Key& __k, _Hash_code_type, std::size_t __n) const { return _M_ranged_hash(__k, __n); } std::size_t _M_bucket_index(const _Hash_node<_Value, false>* __p, std::size_t __n) const { return _M_ranged_hash(_M_extract(__p->_M_v), __n); } bool _M_compare(const _Key& __k, _Hash_code_type, _Hash_node<_Value, false>* __n) const { return _M_eq(__k, _M_extract(__n->_M_v)); } void _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const { } void _M_copy_code(_Hash_node<_Value, false>*, const _Hash_node<_Value, false>*) const { } void _M_swap(_Hash_code_base& __x) { std::swap(_M_extract, __x._M_extract); std::swap(_M_eq, __x._M_eq); std::swap(_M_ranged_hash, __x._M_ranged_hash); } protected: _ExtractKey _M_extract; _Equal _M_eq; _Hash _M_ranged_hash; }; // No specialization for ranged hash function while caching hash codes. // That combination is meaningless, and trying to do it is an error. // Specialization: ranged hash function, cache hash codes. This // combination is meaningless, so we provide only a declaration // and no definition. template struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, true>; // Specialization: hash function and range-hashing function, no // caching of hash codes. H is provided but ignored. Provides // typedef and accessor required by TR1. template struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Default_ranged_hash, false> { typedef _H1 hasher; hasher hash_function() const { return _M_h1; } protected: _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq, const _H1& __h1, const _H2& __h2, const _Default_ranged_hash&) : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { } typedef std::size_t _Hash_code_type; _Hash_code_type _M_hash_code(const _Key& __k) const { return _M_h1(__k); } std::size_t _M_bucket_index(const _Key&, _Hash_code_type __c, std::size_t __n) const { return _M_h2(__c, __n); } std::size_t _M_bucket_index(const _Hash_node<_Value, false>* __p, std::size_t __n) const { return _M_h2(_M_h1(_M_extract(__p->_M_v)), __n); } bool _M_compare(const _Key& __k, _Hash_code_type, _Hash_node<_Value, false>* __n) const { return _M_eq(__k, _M_extract(__n->_M_v)); } void _M_store_code(_Hash_node<_Value, false>*, _Hash_code_type) const { } void _M_copy_code(_Hash_node<_Value, false>*, const _Hash_node<_Value, false>*) const { } void _M_swap(_Hash_code_base& __x) { std::swap(_M_extract, __x._M_extract); std::swap(_M_eq, __x._M_eq); std::swap(_M_h1, __x._M_h1); std::swap(_M_h2, __x._M_h2); } protected: _ExtractKey _M_extract; _Equal _M_eq; _H1 _M_h1; _H2 _M_h2; }; // Specialization: hash function and range-hashing function, // caching hash codes. H is provided but ignored. Provides // typedef and accessor required by TR1. template struct _Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Default_ranged_hash, true> { typedef _H1 hasher; hasher hash_function() const { return _M_h1; } protected: _Hash_code_base(const _ExtractKey& __ex, const _Equal& __eq, const _H1& __h1, const _H2& __h2, const _Default_ranged_hash&) : _M_extract(__ex), _M_eq(__eq), _M_h1(__h1), _M_h2(__h2) { } typedef std::size_t _Hash_code_type; _Hash_code_type _M_hash_code(const _Key& __k) const { return _M_h1(__k); } std::size_t _M_bucket_index(const _Key&, _Hash_code_type __c, std::size_t __n) const { return _M_h2(__c, __n); } std::size_t _M_bucket_index(const _Hash_node<_Value, true>* __p, std::size_t __n) const { return _M_h2(__p->_M_hash_code, __n); } bool _M_compare(const _Key& __k, _Hash_code_type __c, _Hash_node<_Value, true>* __n) const { return __c == __n->_M_hash_code && _M_eq(__k, _M_extract(__n->_M_v)); } void _M_store_code(_Hash_node<_Value, true>* __n, _Hash_code_type __c) const { __n->_M_hash_code = __c; } void _M_copy_code(_Hash_node<_Value, true>* __to, const _Hash_node<_Value, true>* __from) const { __to->_M_hash_code = __from->_M_hash_code; } void _M_swap(_Hash_code_base& __x) { std::swap(_M_extract, __x._M_extract); std::swap(_M_eq, __x._M_eq); std::swap(_M_h1, __x._M_h1); std::swap(_M_h2, __x._M_h2); } protected: _ExtractKey _M_extract; _Equal _M_eq; _H1 _M_h1; _H2 _M_h2; }; } // namespace __detail } _GLIBCXX_END_NAMESPACE_VERSION } c++/8/tr1/climits000064400000002656152640040210007363 0ustar00// TR1 climits -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/climits * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CLIMITS #define _GLIBCXX_TR1_CLIMITS 1 #include #ifndef LLONG_MIN #define LLONG_MIN (-__LONG_LONG_MAX__ - 1) #endif #ifndef LLONG_MAX #define LLONG_MAX __LONG_LONG_MAX__ #endif #ifndef ULLONG_MAX #define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1) #endif #endif // _GLIBCXX_TR1_CLIMITS c++/8/tr1/gamma.tcc000064400000034532152640040210007547 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/gamma.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 6, pp. 253-266 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 213-216 // (4) Gamma, Exploring Euler's Constant, Julian Havil, // Princeton, 2003. #ifndef _GLIBCXX_TR1_GAMMA_TCC #define _GLIBCXX_TR1_GAMMA_TCC 1 #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // Implementation-space details. namespace __detail { /** * @brief This returns Bernoulli numbers from a table or by summation * for larger values. * * Recursion is unstable. * * @param __n the order n of the Bernoulli number. * @return The Bernoulli number of order n. */ template _Tp __bernoulli_series(unsigned int __n) { static const _Tp __num[28] = { _Tp(1UL), -_Tp(1UL) / _Tp(2UL), _Tp(1UL) / _Tp(6UL), _Tp(0UL), -_Tp(1UL) / _Tp(30UL), _Tp(0UL), _Tp(1UL) / _Tp(42UL), _Tp(0UL), -_Tp(1UL) / _Tp(30UL), _Tp(0UL), _Tp(5UL) / _Tp(66UL), _Tp(0UL), -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), _Tp(7UL) / _Tp(6UL), _Tp(0UL), -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), _Tp(43867UL) / _Tp(798UL), _Tp(0UL), -_Tp(174611) / _Tp(330UL), _Tp(0UL), _Tp(854513UL) / _Tp(138UL), _Tp(0UL), -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) }; if (__n == 0) return _Tp(1); if (__n == 1) return -_Tp(1) / _Tp(2); // Take care of the rest of the odd ones. if (__n % 2 == 1) return _Tp(0); // Take care of some small evens that are painful for the series. if (__n < 28) return __num[__n]; _Tp __fact = _Tp(1); if ((__n / 2) % 2 == 0) __fact *= _Tp(-1); for (unsigned int __k = 1; __k <= __n; ++__k) __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); __fact *= _Tp(2); _Tp __sum = _Tp(0); for (unsigned int __i = 1; __i < 1000; ++__i) { _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return __fact * __sum; } /** * @brief This returns Bernoulli number \f$B_n\f$. * * @param __n the order n of the Bernoulli number. * @return The Bernoulli number of order n. */ template inline _Tp __bernoulli(int __n) { return __bernoulli_series<_Tp>(__n); } /** * @brief Return \f$log(\Gamma(x))\f$ by asymptotic expansion * with Bernoulli number coefficients. This is like * Sterling's approximation. * * @param __x The argument of the log of the gamma function. * @return The logarithm of the gamma function. */ template _Tp __log_gamma_bernoulli(_Tp __x) { _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + _Tp(0.5L) * std::log(_Tp(2) * __numeric_constants<_Tp>::__pi()); const _Tp __xx = __x * __x; _Tp __help = _Tp(1) / __x; for ( unsigned int __i = 1; __i < 20; ++__i ) { const _Tp __2i = _Tp(2 * __i); __help /= __2i * (__2i - _Tp(1)) * __xx; __lg += __bernoulli<_Tp>(2 * __i) * __help; } return __lg; } /** * @brief Return \f$log(\Gamma(x))\f$ by the Lanczos method. * This method dominates all others on the positive axis I think. * * @param __x The argument of the log of the gamma function. * @return The logarithm of the gamma function. */ template _Tp __log_gamma_lanczos(_Tp __x) { const _Tp __xm1 = __x - _Tp(1); static const _Tp __lanczos_cheb_7[9] = { _Tp( 0.99999999999980993227684700473478L), _Tp( 676.520368121885098567009190444019L), _Tp(-1259.13921672240287047156078755283L), _Tp( 771.3234287776530788486528258894L), _Tp(-176.61502916214059906584551354L), _Tp( 12.507343278686904814458936853L), _Tp(-0.13857109526572011689554707L), _Tp( 9.984369578019570859563e-6L), _Tp( 1.50563273514931155834e-7L) }; static const _Tp __LOGROOT2PI = _Tp(0.9189385332046727417803297364056176L); _Tp __sum = __lanczos_cheb_7[0]; for(unsigned int __k = 1; __k < 9; ++__k) __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); const _Tp __term1 = (__xm1 + _Tp(0.5L)) * std::log((__xm1 + _Tp(7.5L)) / __numeric_constants<_Tp>::__euler()); const _Tp __term2 = __LOGROOT2PI + std::log(__sum); const _Tp __result = __term1 + (__term2 - _Tp(7)); return __result; } /** * @brief Return \f$ log(|\Gamma(x)|) \f$. * This will return values even for \f$ x < 0 \f$. * To recover the sign of \f$ \Gamma(x) \f$ for * any argument use @a __log_gamma_sign. * * @param __x The argument of the log of the gamma function. * @return The logarithm of the gamma function. */ template _Tp __log_gamma(_Tp __x) { if (__x > _Tp(0.5L)) return __log_gamma_lanczos(__x); else { const _Tp __sin_fact = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); if (__sin_fact == _Tp(0)) std::__throw_domain_error(__N("Argument is nonpositive integer " "in __log_gamma")); return __numeric_constants<_Tp>::__lnpi() - std::log(__sin_fact) - __log_gamma_lanczos(_Tp(1) - __x); } } /** * @brief Return the sign of \f$ \Gamma(x) \f$. * At nonpositive integers zero is returned. * * @param __x The argument of the gamma function. * @return The sign of the gamma function. */ template _Tp __log_gamma_sign(_Tp __x) { if (__x > _Tp(0)) return _Tp(1); else { const _Tp __sin_fact = std::sin(__numeric_constants<_Tp>::__pi() * __x); if (__sin_fact > _Tp(0)) return (1); else if (__sin_fact < _Tp(0)) return -_Tp(1); else return _Tp(0); } } /** * @brief Return the logarithm of the binomial coefficient. * The binomial coefficient is given by: * @f[ * \left( \right) = \frac{n!}{(n-k)! k!} * @f] * * @param __n The first argument of the binomial coefficient. * @param __k The second argument of the binomial coefficient. * @return The binomial coefficient. */ template _Tp __log_bincoef(unsigned int __n, unsigned int __k) { // Max e exponent before overflow. static const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); #if _GLIBCXX_USE_C99_MATH_TR1 _Tp __coeff = _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __n)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __k)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __n - __k)); #else _Tp __coeff = __log_gamma(_Tp(1 + __n)) - __log_gamma(_Tp(1 + __k)) - __log_gamma(_Tp(1 + __n - __k)); #endif } /** * @brief Return the binomial coefficient. * The binomial coefficient is given by: * @f[ * \left( \right) = \frac{n!}{(n-k)! k!} * @f] * * @param __n The first argument of the binomial coefficient. * @param __k The second argument of the binomial coefficient. * @return The binomial coefficient. */ template _Tp __bincoef(unsigned int __n, unsigned int __k) { // Max e exponent before overflow. static const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); if (__log_coeff > __max_bincoeff) return std::numeric_limits<_Tp>::quiet_NaN(); else return std::exp(__log_coeff); } /** * @brief Return \f$ \Gamma(x) \f$. * * @param __x The argument of the gamma function. * @return The gamma function. */ template inline _Tp __gamma(_Tp __x) { return std::exp(__log_gamma(__x)); } /** * @brief Return the digamma function by series expansion. * The digamma or @f$ \psi(x) @f$ function is defined by * @f[ * \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)} * @f] * * The series is given by: * @f[ * \psi(x) = -\gamma_E - \frac{1}{x} * \sum_{k=1}^{\infty} \frac{x}{k(x + k)} * @f] */ template _Tp __psi_series(_Tp __x) { _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; const unsigned int __max_iter = 100000; for (unsigned int __k = 1; __k < __max_iter; ++__k) { const _Tp __term = __x / (__k * (__k + __x)); __sum += __term; if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) break; } return __sum; } /** * @brief Return the digamma function for large argument. * The digamma or @f$ \psi(x) @f$ function is defined by * @f[ * \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)} * @f] * * The asymptotic series is given by: * @f[ * \psi(x) = \ln(x) - \frac{1}{2x} * - \sum_{n=1}^{\infty} \frac{B_{2n}}{2 n x^{2n}} * @f] */ template _Tp __psi_asymp(_Tp __x) { _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; const _Tp __xx = __x * __x; _Tp __xp = __xx; const unsigned int __max_iter = 100; for (unsigned int __k = 1; __k < __max_iter; ++__k) { const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); __sum -= __term; if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) break; __xp *= __xx; } return __sum; } /** * @brief Return the digamma function. * The digamma or @f$ \psi(x) @f$ function is defined by * @f[ * \psi(x) = \frac{\Gamma'(x)}{\Gamma(x)} * @f] * For negative argument the reflection formula is used: * @f[ * \psi(x) = \psi(1-x) - \pi \cot(\pi x) * @f] */ template _Tp __psi(_Tp __x) { const int __n = static_cast(__x + 0.5L); const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x < _Tp(0)) { const _Tp __pi = __numeric_constants<_Tp>::__pi(); return __psi(_Tp(1) - __x) - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); } else if (__x > _Tp(100)) return __psi_asymp(__x); else return __psi_series(__x); } /** * @brief Return the polygamma function @f$ \psi^{(n)}(x) @f$. * * The polygamma function is related to the Hurwitz zeta function: * @f[ * \psi^{(n)}(x) = (-1)^{n+1} m! \zeta(m+1,x) * @f] */ template _Tp __psi(unsigned int __n, _Tp __x) { if (__x <= _Tp(0)) std::__throw_domain_error(__N("Argument out of range " "in __psi")); else if (__n == 0) return __psi(__x); else { const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __ln_nfact = _GLIBCXX_MATH_NS::lgamma(_Tp(__n + 1)); #else const _Tp __ln_nfact = __log_gamma(_Tp(__n + 1)); #endif _Tp __result = std::exp(__ln_nfact) * __hzeta; if (__n % 2 == 1) __result = -__result; return __result; } } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // _GLIBCXX_TR1_GAMMA_TCC c++/8/tr1/fenv.h000064400000002264152640040210007076 0ustar00// TR1 fenv.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/fenv.h * This is a TR1 C++ Library header. */ #ifndef _TR1_FENV_H #define _TR1_FENV_H 1 #include #endif c++/8/tr1/hashtable.h000064400000121101152640040210010063 0ustar00// TR1 hashtable.h header -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/hashtable.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. * @headername{tr1/unordered_set, tr1/unordered_map} */ #ifndef _GLIBCXX_TR1_HASHTABLE_H #define _GLIBCXX_TR1_HASHTABLE_H 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { // Class template _Hashtable, class definition. // Meaning of class template _Hashtable's template parameters // _Key and _Value: arbitrary CopyConstructible types. // _Allocator: an allocator type ([lib.allocator.requirements]) whose // value type is Value. As a conforming extension, we allow for // value type != Value. // _ExtractKey: function object that takes a object of type Value // and returns a value of type _Key. // _Equal: function object that takes two objects of type k and returns // a bool-like value that is true if the two objects are considered equal. // _H1: the hash function. A unary function object with argument type // Key and result type size_t. Return values should be distributed // over the entire range [0, numeric_limits:::max()]. // _H2: the range-hashing function (in the terminology of Tavori and // Dreizin). A binary function object whose argument types and result // type are all size_t. Given arguments r and N, the return value is // in the range [0, N). // _Hash: the ranged hash function (Tavori and Dreizin). A binary function // whose argument types are _Key and size_t and whose result type is // size_t. Given arguments k and N, the return value is in the range // [0, N). Default: hash(k, N) = h2(h1(k), N). If _Hash is anything other // than the default, _H1 and _H2 are ignored. // _RehashPolicy: Policy class with three members, all of which govern // the bucket count. _M_next_bkt(n) returns a bucket count no smaller // than n. _M_bkt_for_elements(n) returns a bucket count appropriate // for an element count of n. _M_need_rehash(n_bkt, n_elt, n_ins) // determines whether, if the current bucket count is n_bkt and the // current element count is n_elt, we need to increase the bucket // count. If so, returns make_pair(true, n), where n is the new // bucket count. If not, returns make_pair(false, ). // ??? Right now it is hard-wired that the number of buckets never // shrinks. Should we allow _RehashPolicy to change that? // __cache_hash_code: bool. true if we store the value of the hash // function along with the value. This is a time-space tradeoff. // Storing it may improve lookup speed by reducing the number of times // we need to call the Equal function. // __constant_iterators: bool. true if iterator and const_iterator are // both constant iterator types. This is true for unordered_set and // unordered_multiset, false for unordered_map and unordered_multimap. // __unique_keys: bool. true if the return value of _Hashtable::count(k) // is always at most one, false if it may be an arbitrary number. This // true for unordered_set and unordered_map, false for unordered_multiset // and unordered_multimap. template class _Hashtable : public __detail::_Rehash_base<_RehashPolicy, _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys> >, public __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, __cache_hash_code>, public __detail::_Map_base<_Key, _Value, _ExtractKey, __unique_keys, _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __cache_hash_code, __constant_iterators, __unique_keys> > { public: typedef _Allocator allocator_type; typedef _Value value_type; typedef _Key key_type; typedef _Equal key_equal; // mapped_type, if present, comes from _Map_base. // hasher, if present, comes from _Hash_code_base. typedef typename _Allocator::difference_type difference_type; typedef typename _Allocator::size_type size_type; typedef typename _Allocator::pointer pointer; typedef typename _Allocator::const_pointer const_pointer; typedef typename _Allocator::reference reference; typedef typename _Allocator::const_reference const_reference; typedef __detail::_Node_iterator local_iterator; typedef __detail::_Node_const_iterator const_local_iterator; typedef __detail::_Hashtable_iterator iterator; typedef __detail::_Hashtable_const_iterator const_iterator; template friend struct __detail::_Map_base; private: typedef __detail::_Hash_node<_Value, __cache_hash_code> _Node; typedef typename _Allocator::template rebind<_Node>::other _Node_allocator_type; typedef typename _Allocator::template rebind<_Node*>::other _Bucket_allocator_type; typedef typename _Allocator::template rebind<_Value>::other _Value_allocator_type; _Node_allocator_type _M_node_allocator; _Node** _M_buckets; size_type _M_bucket_count; size_type _M_element_count; _RehashPolicy _M_rehash_policy; _Node* _M_allocate_node(const value_type& __v); void _M_deallocate_node(_Node* __n); void _M_deallocate_nodes(_Node**, size_type); _Node** _M_allocate_buckets(size_type __n); void _M_deallocate_buckets(_Node**, size_type __n); public: // Constructor, destructor, assignment, swap _Hashtable(size_type __bucket_hint, const _H1&, const _H2&, const _Hash&, const _Equal&, const _ExtractKey&, const allocator_type&); template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bucket_hint, const _H1&, const _H2&, const _Hash&, const _Equal&, const _ExtractKey&, const allocator_type&); _Hashtable(const _Hashtable&); _Hashtable& operator=(const _Hashtable&); ~_Hashtable(); void swap(_Hashtable&); // Basic container operations iterator begin() { iterator __i(_M_buckets); if (!__i._M_cur_node) __i._M_incr_bucket(); return __i; } const_iterator begin() const { const_iterator __i(_M_buckets); if (!__i._M_cur_node) __i._M_incr_bucket(); return __i; } iterator end() { return iterator(_M_buckets + _M_bucket_count); } const_iterator end() const { return const_iterator(_M_buckets + _M_bucket_count); } size_type size() const { return _M_element_count; } bool empty() const { return size() == 0; } allocator_type get_allocator() const { return allocator_type(_M_node_allocator); } _Value_allocator_type _M_get_Value_allocator() const { return _Value_allocator_type(_M_node_allocator); } size_type max_size() const { return _M_node_allocator.max_size(); } // Observers key_equal key_eq() const { return this->_M_eq; } // hash_function, if present, comes from _Hash_code_base. // Bucket operations size_type bucket_count() const { return _M_bucket_count; } size_type max_bucket_count() const { return max_size(); } size_type bucket_size(size_type __n) const { return std::distance(begin(__n), end(__n)); } size_type bucket(const key_type& __k) const { return this->_M_bucket_index(__k, this->_M_hash_code(__k), bucket_count()); } local_iterator begin(size_type __n) { return local_iterator(_M_buckets[__n]); } local_iterator end(size_type) { return local_iterator(0); } const_local_iterator begin(size_type __n) const { return const_local_iterator(_M_buckets[__n]); } const_local_iterator end(size_type) const { return const_local_iterator(0); } float load_factor() const { return static_cast(size()) / static_cast(bucket_count()); } // max_load_factor, if present, comes from _Rehash_base. // Generalization of max_load_factor. Extension, not found in TR1. Only // useful if _RehashPolicy is something other than the default. const _RehashPolicy& __rehash_policy() const { return _M_rehash_policy; } void __rehash_policy(const _RehashPolicy&); // Lookup. iterator find(const key_type& __k); const_iterator find(const key_type& __k) const; size_type count(const key_type& __k) const; std::pair equal_range(const key_type& __k); std::pair equal_range(const key_type& __k) const; private: // Find, insert and erase helper functions // ??? This dispatching is a workaround for the fact that we don't // have partial specialization of member templates; it would be // better to just specialize insert on __unique_keys. There may be a // cleaner workaround. typedef typename __gnu_cxx::__conditional_type<__unique_keys, std::pair, iterator>::__type _Insert_Return_Type; typedef typename __gnu_cxx::__conditional_type<__unique_keys, std::_Select1st<_Insert_Return_Type>, std::_Identity<_Insert_Return_Type> >::__type _Insert_Conv_Type; _Node* _M_find_node(_Node*, const key_type&, typename _Hashtable::_Hash_code_type) const; iterator _M_insert_bucket(const value_type&, size_type, typename _Hashtable::_Hash_code_type); std::pair _M_insert(const value_type&, std::tr1::true_type); iterator _M_insert(const value_type&, std::tr1::false_type); void _M_erase_node(_Node*, _Node**); public: // Insert and erase _Insert_Return_Type insert(const value_type& __v) { return _M_insert(__v, std::tr1::integral_constant()); } iterator insert(iterator, const value_type& __v) { return iterator(_Insert_Conv_Type()(this->insert(__v))); } const_iterator insert(const_iterator, const value_type& __v) { return const_iterator(_Insert_Conv_Type()(this->insert(__v))); } template void insert(_InputIterator __first, _InputIterator __last); iterator erase(iterator); const_iterator erase(const_iterator); size_type erase(const key_type&); iterator erase(iterator, iterator); const_iterator erase(const_iterator, const_iterator); void clear(); // Set number of buckets to be appropriate for container of n element. void rehash(size_type __n); private: // Unconditionally change size of bucket array to n. void _M_rehash(size_type __n); }; // Definitions of class template _Hashtable's out-of-line member functions. template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::_Node* _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_allocate_node(const value_type& __v) { _Node* __n = _M_node_allocator.allocate(1); __try { _M_get_Value_allocator().construct(&__n->_M_v, __v); __n->_M_next = 0; return __n; } __catch(...) { _M_node_allocator.deallocate(__n, 1); __throw_exception_again; } } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_deallocate_node(_Node* __n) { _M_get_Value_allocator().destroy(&__n->_M_v); _M_node_allocator.deallocate(__n, 1); } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_deallocate_nodes(_Node** __array, size_type __n) { for (size_type __i = 0; __i < __n; ++__i) { _Node* __p = __array[__i]; while (__p) { _Node* __tmp = __p; __p = __p->_M_next; _M_deallocate_node(__tmp); } __array[__i] = 0; } } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::_Node** _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_allocate_buckets(size_type __n) { _Bucket_allocator_type __alloc(_M_node_allocator); // We allocate one extra bucket to hold a sentinel, an arbitrary // non-null pointer. Iterator increment relies on this. _Node** __p = __alloc.allocate(__n + 1); std::fill(__p, __p + __n, (_Node*) 0); __p[__n] = reinterpret_cast<_Node*>(0x1000); return __p; } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_deallocate_buckets(_Node** __p, size_type __n) { _Bucket_allocator_type __alloc(_M_node_allocator); __alloc.deallocate(__p, __n + 1); } template _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _Hashtable(size_type __bucket_hint, const _H1& __h1, const _H2& __h2, const _Hash& __h, const _Equal& __eq, const _ExtractKey& __exk, const allocator_type& __a) : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(), __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, __chc>(__exk, __eq, __h1, __h2, __h), __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(), _M_node_allocator(__a), _M_bucket_count(0), _M_element_count(0), _M_rehash_policy() { _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint); _M_buckets = _M_allocate_buckets(_M_bucket_count); } template template _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bucket_hint, const _H1& __h1, const _H2& __h2, const _Hash& __h, const _Equal& __eq, const _ExtractKey& __exk, const allocator_type& __a) : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(), __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, __chc>(__exk, __eq, __h1, __h2, __h), __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(), _M_node_allocator(__a), _M_bucket_count(0), _M_element_count(0), _M_rehash_policy() { _M_bucket_count = std::max(_M_rehash_policy._M_next_bkt(__bucket_hint), _M_rehash_policy. _M_bkt_for_elements(__detail:: __distance_fw(__f, __l))); _M_buckets = _M_allocate_buckets(_M_bucket_count); __try { for (; __f != __l; ++__f) this->insert(*__f); } __catch(...) { clear(); _M_deallocate_buckets(_M_buckets, _M_bucket_count); __throw_exception_again; } } template _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _Hashtable(const _Hashtable& __ht) : __detail::_Rehash_base<_RehashPolicy, _Hashtable>(__ht), __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, __chc>(__ht), __detail::_Map_base<_Key, _Value, _ExtractKey, __uk, _Hashtable>(__ht), _M_node_allocator(__ht._M_node_allocator), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { _M_buckets = _M_allocate_buckets(_M_bucket_count); __try { for (size_type __i = 0; __i < __ht._M_bucket_count; ++__i) { _Node* __n = __ht._M_buckets[__i]; _Node** __tail = _M_buckets + __i; while (__n) { *__tail = _M_allocate_node(__n->_M_v); this->_M_copy_code(*__tail, __n); __tail = &((*__tail)->_M_next); __n = __n->_M_next; } } } __catch(...) { clear(); _M_deallocate_buckets(_M_buckets, _M_bucket_count); __throw_exception_again; } } template _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>& _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: operator=(const _Hashtable& __ht) { _Hashtable __tmp(__ht); this->swap(__tmp); return *this; } template _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: ~_Hashtable() { clear(); _M_deallocate_buckets(_M_buckets, _M_bucket_count); } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: swap(_Hashtable& __x) { // The only base class with member variables is hash_code_base. We // define _Hash_code_base::_M_swap because different specializations // have different members. __detail::_Hash_code_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, __chc>::_M_swap(__x); // _GLIBCXX_RESOLVE_LIB_DEFECTS // 431. Swapping containers with unequal allocators. std::__alloc_swap<_Node_allocator_type>::_S_do_it(_M_node_allocator, __x._M_node_allocator); std::swap(_M_rehash_policy, __x._M_rehash_policy); std::swap(_M_buckets, __x._M_buckets); std::swap(_M_bucket_count, __x._M_bucket_count); std::swap(_M_element_count, __x._M_element_count); } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: __rehash_policy(const _RehashPolicy& __pol) { _M_rehash_policy = __pol; size_type __n_bkt = __pol._M_bkt_for_elements(_M_element_count); if (__n_bkt > _M_bucket_count) _M_rehash(__n_bkt); } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: find(const key_type& __k) { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); _Node* __p = _M_find_node(_M_buckets[__n], __k, __code); return __p ? iterator(__p, _M_buckets + __n) : this->end(); } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::const_iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: find(const key_type& __k) const { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); _Node* __p = _M_find_node(_M_buckets[__n], __k, __code); return __p ? const_iterator(__p, _M_buckets + __n) : this->end(); } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::size_type _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: count(const key_type& __k) const { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); std::size_t __result = 0; for (_Node* __p = _M_buckets[__n]; __p; __p = __p->_M_next) if (this->_M_compare(__k, __code, __p)) ++__result; return __result; } template std::pair::iterator, typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator> _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: equal_range(const key_type& __k) { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); _Node** __head = _M_buckets + __n; _Node* __p = _M_find_node(*__head, __k, __code); if (__p) { _Node* __p1 = __p->_M_next; for (; __p1; __p1 = __p1->_M_next) if (!this->_M_compare(__k, __code, __p1)) break; iterator __first(__p, __head); iterator __last(__p1, __head); if (!__p1) __last._M_incr_bucket(); return std::make_pair(__first, __last); } else return std::make_pair(this->end(), this->end()); } template std::pair::const_iterator, typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::const_iterator> _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: equal_range(const key_type& __k) const { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); _Node** __head = _M_buckets + __n; _Node* __p = _M_find_node(*__head, __k, __code); if (__p) { _Node* __p1 = __p->_M_next; for (; __p1; __p1 = __p1->_M_next) if (!this->_M_compare(__k, __code, __p1)) break; const_iterator __first(__p, __head); const_iterator __last(__p1, __head); if (!__p1) __last._M_incr_bucket(); return std::make_pair(__first, __last); } else return std::make_pair(this->end(), this->end()); } // Find the node whose key compares equal to k, beginning the search // at p (usually the head of a bucket). Return zero if no node is found. template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::_Node* _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_find_node(_Node* __p, const key_type& __k, typename _Hashtable::_Hash_code_type __code) const { for (; __p; __p = __p->_M_next) if (this->_M_compare(__k, __code, __p)) return __p; return 0; } // Insert v in bucket n (assumes no element with its key already present). template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_insert_bucket(const value_type& __v, size_type __n, typename _Hashtable::_Hash_code_type __code) { std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); // Allocate the new node before doing the rehash so that we don't // do a rehash if the allocation throws. _Node* __new_node = _M_allocate_node(__v); __try { if (__do_rehash.first) { const key_type& __k = this->_M_extract(__v); __n = this->_M_bucket_index(__k, __code, __do_rehash.second); _M_rehash(__do_rehash.second); } __new_node->_M_next = _M_buckets[__n]; this->_M_store_code(__new_node, __code); _M_buckets[__n] = __new_node; ++_M_element_count; return iterator(__new_node, _M_buckets + __n); } __catch(...) { _M_deallocate_node(__new_node); __throw_exception_again; } } // Insert v if no element with its key is already present. template std::pair::iterator, bool> _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_insert(const value_type& __v, std::tr1::true_type) { const key_type& __k = this->_M_extract(__v); typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count); if (_Node* __p = _M_find_node(_M_buckets[__n], __k, __code)) return std::make_pair(iterator(__p, _M_buckets + __n), false); return std::make_pair(_M_insert_bucket(__v, __n, __code), true); } // Insert v unconditionally. template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_insert(const value_type& __v, std::tr1::false_type) { std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); if (__do_rehash.first) _M_rehash(__do_rehash.second); const key_type& __k = this->_M_extract(__v); typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); size_type __n = this->_M_bucket_index(__k, __code, _M_bucket_count); // First find the node, avoid leaking new_node if compare throws. _Node* __prev = _M_find_node(_M_buckets[__n], __k, __code); _Node* __new_node = _M_allocate_node(__v); if (__prev) { __new_node->_M_next = __prev->_M_next; __prev->_M_next = __new_node; } else { __new_node->_M_next = _M_buckets[__n]; _M_buckets[__n] = __new_node; } this->_M_store_code(__new_node, __code); ++_M_element_count; return iterator(__new_node, _M_buckets + __n); } // For erase(iterator) and erase(const_iterator). template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_erase_node(_Node* __p, _Node** __b) { _Node* __cur = *__b; if (__cur == __p) *__b = __cur->_M_next; else { _Node* __next = __cur->_M_next; while (__next != __p) { __cur = __next; __next = __cur->_M_next; } __cur->_M_next = __next->_M_next; } _M_deallocate_node(__p); --_M_element_count; } template template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: insert(_InputIterator __first, _InputIterator __last) { size_type __n_elt = __detail::__distance_fw(__first, __last); std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n_elt); if (__do_rehash.first) _M_rehash(__do_rehash.second); for (; __first != __last; ++__first) this->insert(*__first); } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: erase(iterator __it) { iterator __result = __it; ++__result; _M_erase_node(__it._M_cur_node, __it._M_cur_bucket); return __result; } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::const_iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: erase(const_iterator __it) { const_iterator __result = __it; ++__result; _M_erase_node(__it._M_cur_node, __it._M_cur_bucket); return __result; } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::size_type _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: erase(const key_type& __k) { typename _Hashtable::_Hash_code_type __code = this->_M_hash_code(__k); std::size_t __n = this->_M_bucket_index(__k, __code, _M_bucket_count); size_type __result = 0; _Node** __slot = _M_buckets + __n; while (*__slot && !this->_M_compare(__k, __code, *__slot)) __slot = &((*__slot)->_M_next); _Node** __saved_slot = 0; while (*__slot && this->_M_compare(__k, __code, *__slot)) { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 526. Is it undefined if a function in the standard changes // in parameters? if (&this->_M_extract((*__slot)->_M_v) != &__k) { _Node* __p = *__slot; *__slot = __p->_M_next; _M_deallocate_node(__p); --_M_element_count; ++__result; } else { __saved_slot = __slot; __slot = &((*__slot)->_M_next); } } if (__saved_slot) { _Node* __p = *__saved_slot; *__saved_slot = __p->_M_next; _M_deallocate_node(__p); --_M_element_count; ++__result; } return __result; } // ??? This could be optimized by taking advantage of the bucket // structure, but it's not clear that it's worth doing. It probably // wouldn't even be an optimization unless the load factor is large. template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: erase(iterator __first, iterator __last) { while (__first != __last) __first = this->erase(__first); return __last; } template typename _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>::const_iterator _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: erase(const_iterator __first, const_iterator __last) { while (__first != __last) __first = this->erase(__first); return __last; } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: clear() { _M_deallocate_nodes(_M_buckets, _M_bucket_count); _M_element_count = 0; } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: rehash(size_type __n) { _M_rehash(std::max(_M_rehash_policy._M_next_bkt(__n), _M_rehash_policy._M_bkt_for_elements(_M_element_count + 1))); } template void _Hashtable<_Key, _Value, _Allocator, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, __chc, __cit, __uk>:: _M_rehash(size_type __n) { _Node** __new_array = _M_allocate_buckets(__n); __try { for (size_type __i = 0; __i < _M_bucket_count; ++__i) while (_Node* __p = _M_buckets[__i]) { std::size_t __new_index = this->_M_bucket_index(__p, __n); _M_buckets[__i] = __p->_M_next; __p->_M_next = __new_array[__new_index]; __new_array[__new_index] = __p; } _M_deallocate_buckets(_M_buckets, _M_bucket_count); _M_bucket_count = __n; _M_buckets = __new_array; } __catch(...) { // A failure here means that a hash function threw an exception. // We can't restore the previous state without calling the hash // function again, so the only sensible recovery is to delete // everything. _M_deallocate_nodes(__new_array, __n); _M_deallocate_buckets(__new_array, __n); _M_deallocate_nodes(_M_buckets, _M_bucket_count); _M_element_count = 0; __throw_exception_again; } } } // namespace tr1 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // _GLIBCXX_TR1_HASHTABLE_H c++/8/tr1/riemann_zeta.tcc000064400000033357152640040210011145 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/riemann_zeta.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // Ed. by Milton Abramowitz and Irene A. Stegun, // Dover Publications, New-York, Section 5, pp. 807-808. // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Gamma, Exploring Euler's Constant, Julian Havil, // Princeton, 2003. #ifndef _GLIBCXX_TR1_RIEMANN_ZETA_TCC #define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1 #include "special_function_util.h" namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Compute the Riemann zeta function @f$ \zeta(s) @f$ * by summation for s > 1. * * The Riemann zeta function is defined by: * \f[ * \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1 * \f] * For s < 1 use the reflection formula: * \f[ * \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s) * \f] */ template _Tp __riemann_zeta_sum(_Tp __s) { // A user shouldn't get to this. if (__s < _Tp(1)) std::__throw_domain_error(__N("Bad argument in zeta sum.")); const unsigned int max_iter = 10000; _Tp __zeta = _Tp(0); for (unsigned int __k = 1; __k < max_iter; ++__k) { _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); if (__term < std::numeric_limits<_Tp>::epsilon()) { break; } __zeta += __term; } return __zeta; } /** * @brief Evaluate the Riemann zeta function @f$ \zeta(s) @f$ * by an alternate series for s > 0. * * The Riemann zeta function is defined by: * \f[ * \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1 * \f] * For s < 1 use the reflection formula: * \f[ * \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s) * \f] */ template _Tp __riemann_zeta_alt(_Tp __s) { _Tp __sgn = _Tp(1); _Tp __zeta = _Tp(0); for (unsigned int __i = 1; __i < 10000000; ++__i) { _Tp __term = __sgn / std::pow(__i, __s); if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) break; __zeta += __term; __sgn *= _Tp(-1); } __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); return __zeta; } /** * @brief Evaluate the Riemann zeta function by series for all s != 1. * Convergence is great until largish negative numbers. * Then the convergence of the > 0 sum gets better. * * The series is: * \f[ * \zeta(s) = \frac{1}{1-2^{1-s}} * \sum_{n=0}^{\infty} \frac{1}{2^{n+1}} * \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (k+1)^{-s} * \f] * Havil 2003, p. 206. * * The Riemann zeta function is defined by: * \f[ * \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1 * \f] * For s < 1 use the reflection formula: * \f[ * \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s) * \f] */ template _Tp __riemann_zeta_glob(_Tp __s) { _Tp __zeta = _Tp(0); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); // Max e exponent before overflow. const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); // This series works until the binomial coefficient blows up // so use reflection. if (__s < _Tp(0)) { #if _GLIBCXX_USE_C99_MATH_TR1 if (_GLIBCXX_MATH_NS::fmod(__s,_Tp(2)) == _Tp(0)) return _Tp(0); else #endif { _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) #if _GLIBCXX_USE_C99_MATH_TR1 * std::exp(_GLIBCXX_MATH_NS::lgamma(_Tp(1) - __s)) #else * std::exp(__log_gamma(_Tp(1) - __s)) #endif / __numeric_constants<_Tp>::__pi(); return __zeta; } } _Tp __num = _Tp(0.5L); const unsigned int __maxit = 10000; for (unsigned int __i = 0; __i < __maxit; ++__i) { bool __punt = false; _Tp __sgn = _Tp(1); _Tp __term = _Tp(0); for (unsigned int __j = 0; __j <= __i; ++__j) { #if _GLIBCXX_USE_C99_MATH_TR1 _Tp __bincoeff = _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __i)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __j)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __i - __j)); #else _Tp __bincoeff = __log_gamma(_Tp(1 + __i)) - __log_gamma(_Tp(1 + __j)) - __log_gamma(_Tp(1 + __i - __j)); #endif if (__bincoeff > __max_bincoeff) { // This only gets hit for x << 0. __punt = true; break; } __bincoeff = std::exp(__bincoeff); __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); __sgn *= _Tp(-1); } if (__punt) break; __term *= __num; __zeta += __term; if (std::abs(__term/__zeta) < __eps) break; __num *= _Tp(0.5L); } __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); return __zeta; } /** * @brief Compute the Riemann zeta function @f$ \zeta(s) @f$ * using the product over prime factors. * \f[ * \zeta(s) = \Pi_{i=1}^\infty \frac{1}{1 - p_i^{-s}} * \f] * where @f$ {p_i} @f$ are the prime numbers. * * The Riemann zeta function is defined by: * \f[ * \zeta(s) = \sum_{k=1}^{\infty} \frac{1}{k^{s}} for s > 1 * \f] * For s < 1 use the reflection formula: * \f[ * \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s) * \f] */ template _Tp __riemann_zeta_product(_Tp __s) { static const _Tp __prime[] = { _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) }; static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); _Tp __zeta = _Tp(1); for (unsigned int __i = 0; __i < __num_primes; ++__i) { const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); __zeta *= __fact; if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) break; } __zeta = _Tp(1) / __zeta; return __zeta; } /** * @brief Return the Riemann zeta function @f$ \zeta(s) @f$. * * The Riemann zeta function is defined by: * \f[ * \zeta(s) = \sum_{k=1}^{\infty} k^{-s} for s > 1 * \frac{(2\pi)^s}{pi} sin(\frac{\pi s}{2}) * \Gamma (1 - s) \zeta (1 - s) for s < 1 * \f] * For s < 1 use the reflection formula: * \f[ * \zeta(s) = 2^s \pi^{s-1} \Gamma(1-s) \zeta(1-s) * \f] */ template _Tp __riemann_zeta(_Tp __s) { if (__isnan(__s)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__s == _Tp(1)) return std::numeric_limits<_Tp>::infinity(); else if (__s < -_Tp(19)) { _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) #if _GLIBCXX_USE_C99_MATH_TR1 * std::exp(_GLIBCXX_MATH_NS::lgamma(_Tp(1) - __s)) #else * std::exp(__log_gamma(_Tp(1) - __s)) #endif / __numeric_constants<_Tp>::__pi(); return __zeta; } else if (__s < _Tp(20)) { // Global double sum or McLaurin? bool __glob = true; if (__glob) return __riemann_zeta_glob(__s); else { if (__s > _Tp(1)) return __riemann_zeta_sum(__s); else { _Tp __zeta = std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) #if _GLIBCXX_USE_C99_MATH_TR1 * _GLIBCXX_MATH_NS::tgamma(_Tp(1) - __s) #else * std::exp(__log_gamma(_Tp(1) - __s)) #endif * __riemann_zeta_sum(_Tp(1) - __s); return __zeta; } } } else return __riemann_zeta_product(__s); } /** * @brief Return the Hurwitz zeta function @f$ \zeta(x,s) @f$ * for all s != 1 and x > -1. * * The Hurwitz zeta function is defined by: * @f[ * \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s} * @f] * The Riemann zeta function is a special case: * @f[ * \zeta(s) = \zeta(1,s) * @f] * * This functions uses the double sum that converges for s != 1 * and x > -1: * @f[ * \zeta(x,s) = \frac{1}{s-1} * \sum_{n=0}^{\infty} \frac{1}{n + 1} * \sum_{k=0}^{n} (-1)^k \frac{n!}{(n-k)!k!} (x+k)^{-s} * @f] */ template _Tp __hurwitz_zeta_glob(_Tp __a, _Tp __s) { _Tp __zeta = _Tp(0); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); // Max e exponent before overflow. const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); const unsigned int __maxit = 10000; for (unsigned int __i = 0; __i < __maxit; ++__i) { bool __punt = false; _Tp __sgn = _Tp(1); _Tp __term = _Tp(0); for (unsigned int __j = 0; __j <= __i; ++__j) { #if _GLIBCXX_USE_C99_MATH_TR1 _Tp __bincoeff = _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __i)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __j)) - _GLIBCXX_MATH_NS::lgamma(_Tp(1 + __i - __j)); #else _Tp __bincoeff = __log_gamma(_Tp(1 + __i)) - __log_gamma(_Tp(1 + __j)) - __log_gamma(_Tp(1 + __i - __j)); #endif if (__bincoeff > __max_bincoeff) { // This only gets hit for x << 0. __punt = true; break; } __bincoeff = std::exp(__bincoeff); __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); __sgn *= _Tp(-1); } if (__punt) break; __term /= _Tp(__i + 1); if (std::abs(__term / __zeta) < __eps) break; __zeta += __term; } __zeta /= __s - _Tp(1); return __zeta; } /** * @brief Return the Hurwitz zeta function @f$ \zeta(x,s) @f$ * for all s != 1 and x > -1. * * The Hurwitz zeta function is defined by: * @f[ * \zeta(x,s) = \sum_{n=0}^{\infty} \frac{1}{(n + x)^s} * @f] * The Riemann zeta function is a special case: * @f[ * \zeta(s) = \zeta(1,s) * @f] */ template inline _Tp __hurwitz_zeta(_Tp __a, _Tp __s) { return __hurwitz_zeta_glob(__a, __s); } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC c++/8/tr1/legendre_function.tcc000064400000025235152640040210012157 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/legendre_function.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) Handbook of Mathematical Functions, // ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 8, pp. 331-341 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 252-254 #ifndef _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC #define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1 #include "special_function_util.h" namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Return the Legendre polynomial by recursion on order * @f$ l @f$. * * The Legendre function of @f$ l @f$ and @f$ x @f$, * @f$ P_l(x) @f$, is defined by: * @f[ * P_l(x) = \frac{1}{2^l l!}\frac{d^l}{dx^l}(x^2 - 1)^{l} * @f] * * @param l The order of the Legendre polynomial. @f$l >= 0@f$. * @param x The argument of the Legendre polynomial. @f$|x| <= 1@f$. */ template _Tp __poly_legendre_p(unsigned int __l, _Tp __x) { if ((__x < _Tp(-1)) || (__x > _Tp(+1))) std::__throw_domain_error(__N("Argument out of range" " in __poly_legendre_p.")); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == +_Tp(1)) return +_Tp(1); else if (__x == -_Tp(1)) return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); else { _Tp __p_lm2 = _Tp(1); if (__l == 0) return __p_lm2; _Tp __p_lm1 = __x; if (__l == 1) return __p_lm1; _Tp __p_l = 0; for (unsigned int __ll = 2; __ll <= __l; ++__ll) { // This arrangement is supposed to be better for roundoff // protection, Arfken, 2nd Ed, Eq 12.17a. __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); __p_lm2 = __p_lm1; __p_lm1 = __p_l; } return __p_l; } } /** * @brief Return the associated Legendre function by recursion * on @f$ l @f$. * * The associated Legendre function is derived from the Legendre function * @f$ P_l(x) @f$ by the Rodrigues formula: * @f[ * P_l^m(x) = (1 - x^2)^{m/2}\frac{d^m}{dx^m}P_l(x) * @f] * * @param l The order of the associated Legendre function. * @f$ l >= 0 @f$. * @param m The order of the associated Legendre function. * @f$ m <= l @f$. * @param x The argument of the associated Legendre function. * @f$ |x| <= 1 @f$. */ template _Tp __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x) { if (__x < _Tp(-1) || __x > _Tp(+1)) std::__throw_domain_error(__N("Argument out of range" " in __assoc_legendre_p.")); else if (__m > __l) std::__throw_domain_error(__N("Degree out of range" " in __assoc_legendre_p.")); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__m == 0) return __poly_legendre_p(__l, __x); else { _Tp __p_mm = _Tp(1); if (__m > 0) { // Two square roots seem more accurate more of the time // than just one. _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); _Tp __fact = _Tp(1); for (unsigned int __i = 1; __i <= __m; ++__i) { __p_mm *= -__fact * __root; __fact += _Tp(2); } } if (__l == __m) return __p_mm; _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; if (__l == __m + 1) return __p_mp1m; _Tp __p_lm2m = __p_mm; _Tp __P_lm1m = __p_mp1m; _Tp __p_lm = _Tp(0); for (unsigned int __j = __m + 2; __j <= __l; ++__j) { __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); __p_lm2m = __P_lm1m; __P_lm1m = __p_lm; } return __p_lm; } } /** * @brief Return the spherical associated Legendre function. * * The spherical associated Legendre function of @f$ l @f$, @f$ m @f$, * and @f$ \theta @f$ is defined as @f$ Y_l^m(\theta,0) @f$ where * @f[ * Y_l^m(\theta,\phi) = (-1)^m[\frac{(2l+1)}{4\pi} * \frac{(l-m)!}{(l+m)!}] * P_l^m(\cos\theta) \exp^{im\phi} * @f] * is the spherical harmonic function and @f$ P_l^m(x) @f$ is the * associated Legendre function. * * This function differs from the associated Legendre function by * argument (@f$x = \cos(\theta)@f$) and by a normalization factor * but this factor is rather large for large @f$ l @f$ and @f$ m @f$ * and so this function is stable for larger differences of @f$ l @f$ * and @f$ m @f$. * * @param l The order of the spherical associated Legendre function. * @f$ l >= 0 @f$. * @param m The order of the spherical associated Legendre function. * @f$ m <= l @f$. * @param theta The radian angle argument of the spherical associated * Legendre function. */ template _Tp __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) { if (__isnan(__theta)) return std::numeric_limits<_Tp>::quiet_NaN(); const _Tp __x = std::cos(__theta); if (__l < __m) { std::__throw_domain_error(__N("Bad argument " "in __sph_legendre.")); } else if (__m == 0) { _Tp __P = __poly_legendre_p(__l, __x); _Tp __fact = std::sqrt(_Tp(2 * __l + 1) / (_Tp(4) * __numeric_constants<_Tp>::__pi())); __P *= __fact; return __P; } else if (__x == _Tp(1) || __x == -_Tp(1)) { // m > 0 here return _Tp(0); } else { // m > 0 and |x| < 1 here // Starting value for recursion. // Y_m^m(x) = sqrt( (2m+1)/(4pi m) gamma(m+1/2)/gamma(m) ) // (-1)^m (1-x^2)^(m/2) / pi^(1/4) const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __lncirc = _GLIBCXX_MATH_NS::log1p(-__x * __x); #else const _Tp __lncirc = std::log(_Tp(1) - __x * __x); #endif // Gamma(m+1/2) / Gamma(m) #if _GLIBCXX_USE_C99_MATH_TR1 const _Tp __lnpoch = _GLIBCXX_MATH_NS::lgamma(_Tp(__m + _Tp(0.5L))) - _GLIBCXX_MATH_NS::lgamma(_Tp(__m)); #else const _Tp __lnpoch = __log_gamma(_Tp(__m + _Tp(0.5L))) - __log_gamma(_Tp(__m)); #endif const _Tp __lnpre_val = -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + _Tp(0.5L) * (__lnpoch + __m * __lncirc); _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) / (_Tp(4) * __numeric_constants<_Tp>::__pi())); _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); _Tp __y_mp1m = __y_mp1m_factor * __y_mm; if (__l == __m) { return __y_mm; } else if (__l == __m + 1) { return __y_mp1m; } else { _Tp __y_lm = _Tp(0); // Compute Y_l^m, l > m+1, upward recursion on l. for ( int __ll = __m + 2; __ll <= __l; ++__ll) { const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) * _Tp(2 * __ll - 1)); const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) / _Tp(2 * __ll - 3)); __y_lm = (__x * __y_mp1m * __fact1 - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); __y_mm = __y_mp1m; __y_mp1m = __y_lm; } return __y_lm; } } } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC c++/8/tr1/inttypes.h000064400000002363152640040210010017 0ustar00// TR1 inttypes.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/inttypes.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_INTTYPES_H #define _GLIBCXX_TR1_INTTYPES_H 1 #include #endif // _GLIBCXX_TR1_INTTYPES_H c++/8/tr1/shared_ptr.h000064400000077540152640040210010304 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . // shared_count.hpp // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. // shared_ptr.hpp // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes. // Copyright (C) 2001, 2002, 2003 Peter Dimov // weak_ptr.hpp // Copyright (C) 2001, 2002, 2003 Peter Dimov // enable_shared_from_this.hpp // Copyright (C) 2002 Peter Dimov // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // GCC Note: based on version 1.32.0 of the Boost library. /** @file tr1/shared_ptr.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/memory} */ #ifndef _TR1_SHARED_PTR_H #define _TR1_SHARED_PTR_H 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { /** * @brief Exception possibly thrown by @c shared_ptr. * @ingroup exceptions */ class bad_weak_ptr : public std::exception { public: virtual char const* what() const throw() { return "tr1::bad_weak_ptr"; } }; // Substitute for bad_weak_ptr object in the case of -fno-exceptions. inline void __throw_bad_weak_ptr() { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); } using __gnu_cxx::_Lock_policy; using __gnu_cxx::__default_lock_policy; using __gnu_cxx::_S_single; using __gnu_cxx::_S_mutex; using __gnu_cxx::_S_atomic; // Empty helper class except when the template argument is _S_mutex. template<_Lock_policy _Lp> class _Mutex_base { protected: // The atomic policy uses fully-fenced builtins, single doesn't care. enum { _S_need_barriers = 0 }; }; template<> class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex { protected: // This policy is used when atomic builtins are not available. // The replacement atomic operations might not have the necessary // memory barriers. enum { _S_need_barriers = 1 }; }; template<_Lock_policy _Lp = __default_lock_policy> class _Sp_counted_base : public _Mutex_base<_Lp> { public: _Sp_counted_base() : _M_use_count(1), _M_weak_count(1) { } virtual ~_Sp_counted_base() // nothrow { } // Called when _M_use_count drops to zero, to release the resources // managed by *this. virtual void _M_dispose() = 0; // nothrow // Called when _M_weak_count drops to zero. virtual void _M_destroy() // nothrow { delete this; } virtual void* _M_get_deleter(const std::type_info&) = 0; void _M_add_ref_copy() { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } void _M_add_ref_lock(); void _M_release() // nothrow { // Be race-detector-friendly. For more info see bits/c++config. _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) { _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count); _M_dispose(); // There must be a memory barrier between dispose() and destroy() // to ensure that the effects of dispose() are observed in the // thread that runs destroy(). // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html if (_Mutex_base<_Lp>::_S_need_barriers) { __atomic_thread_fence (__ATOMIC_ACQ_REL); } // Be race-detector-friendly. For more info see bits/c++config. _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); _M_destroy(); } } } void _M_weak_add_ref() // nothrow { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } void _M_weak_release() // nothrow { // Be race-detector-friendly. For more info see bits/c++config. _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); if (_Mutex_base<_Lp>::_S_need_barriers) { // See _M_release(), // destroy() must observe results of dispose() __atomic_thread_fence (__ATOMIC_ACQ_REL); } _M_destroy(); } } long _M_get_use_count() const // nothrow { // No memory barrier is used here so there is no synchronization // with other threads. return const_cast(_M_use_count); } private: _Sp_counted_base(_Sp_counted_base const&); _Sp_counted_base& operator=(_Sp_counted_base const&); _Atomic_word _M_use_count; // #shared _Atomic_word _M_weak_count; // #weak + (#shared != 0) }; template<> inline void _Sp_counted_base<_S_single>:: _M_add_ref_lock() { if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) { _M_use_count = 0; __throw_bad_weak_ptr(); } } template<> inline void _Sp_counted_base<_S_mutex>:: _M_add_ref_lock() { __gnu_cxx::__scoped_lock sentry(*this); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) { _M_use_count = 0; __throw_bad_weak_ptr(); } } template<> inline void _Sp_counted_base<_S_atomic>:: _M_add_ref_lock() { // Perform lock-free add-if-not-zero operation. _Atomic_word __count = _M_use_count; do { if (__count == 0) __throw_bad_weak_ptr(); // Replace the current counter value with the old value + 1, as // long as it's not changed meanwhile. } while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, true, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)); } template class _Sp_counted_base_impl : public _Sp_counted_base<_Lp> { public: // Precondition: __d(__p) must not throw. _Sp_counted_base_impl(_Ptr __p, _Deleter __d) : _M_ptr(__p), _M_del(__d) { } virtual void _M_dispose() // nothrow { _M_del(_M_ptr); } virtual void* _M_get_deleter(const std::type_info& __ti) { #if __cpp_rtti return __ti == typeid(_Deleter) ? &_M_del : 0; #else return 0; #endif } private: _Sp_counted_base_impl(const _Sp_counted_base_impl&); _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&); _Ptr _M_ptr; // copy constructor must not throw _Deleter _M_del; // copy constructor must not throw }; template<_Lock_policy _Lp = __default_lock_policy> class __weak_count; template struct _Sp_deleter { typedef void result_type; typedef _Tp* argument_type; void operator()(_Tp* __p) const { delete __p; } }; template<_Lock_policy _Lp = __default_lock_policy> class __shared_count { public: __shared_count() : _M_pi(0) // nothrow { } template __shared_count(_Ptr __p) : _M_pi(0) { __try { typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp; _M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>( __p, _Sp_deleter<_Tp>()); } __catch(...) { delete __p; __throw_exception_again; } } template __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) { __try { _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d); } __catch(...) { __d(__p); // Call _Deleter on __p. __throw_exception_again; } } // Special case for auto_ptr<_Tp> to provide the strong guarantee. template explicit __shared_count(std::auto_ptr<_Tp>& __r) : _M_pi(new _Sp_counted_base_impl<_Tp*, _Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>())) { __r.release(); } // Throw bad_weak_ptr when __r._M_get_use_count() == 0. explicit __shared_count(const __weak_count<_Lp>& __r); ~__shared_count() // nothrow { if (_M_pi != 0) _M_pi->_M_release(); } __shared_count(const __shared_count& __r) : _M_pi(__r._M_pi) // nothrow { if (_M_pi != 0) _M_pi->_M_add_ref_copy(); } __shared_count& operator=(const __shared_count& __r) // nothrow { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != _M_pi) { if (__tmp != 0) __tmp->_M_add_ref_copy(); if (_M_pi != 0) _M_pi->_M_release(); _M_pi = __tmp; } return *this; } void _M_swap(__shared_count& __r) // nothrow { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const // nothrow { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } bool _M_unique() const // nothrow { return this->_M_get_use_count() == 1; } friend inline bool operator==(const __shared_count& __a, const __shared_count& __b) { return __a._M_pi == __b._M_pi; } friend inline bool operator<(const __shared_count& __a, const __shared_count& __b) { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } void* _M_get_deleter(const std::type_info& __ti) const { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; } private: friend class __weak_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; template<_Lock_policy _Lp> class __weak_count { public: __weak_count() : _M_pi(0) // nothrow { } __weak_count(const __shared_count<_Lp>& __r) : _M_pi(__r._M_pi) // nothrow { if (_M_pi != 0) _M_pi->_M_weak_add_ref(); } __weak_count(const __weak_count<_Lp>& __r) : _M_pi(__r._M_pi) // nothrow { if (_M_pi != 0) _M_pi->_M_weak_add_ref(); } ~__weak_count() // nothrow { if (_M_pi != 0) _M_pi->_M_weak_release(); } __weak_count<_Lp>& operator=(const __shared_count<_Lp>& __r) // nothrow { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != 0) __tmp->_M_weak_add_ref(); if (_M_pi != 0) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } __weak_count<_Lp>& operator=(const __weak_count<_Lp>& __r) // nothrow { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != 0) __tmp->_M_weak_add_ref(); if (_M_pi != 0) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } void _M_swap(__weak_count<_Lp>& __r) // nothrow { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const // nothrow { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } friend inline bool operator==(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) { return __a._M_pi == __b._M_pi; } friend inline bool operator<(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } private: friend class __shared_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; // now that __weak_count is defined we can define this constructor: template<_Lock_policy _Lp> inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r) : _M_pi(__r._M_pi) { if (_M_pi != 0) _M_pi->_M_add_ref_lock(); else __throw_bad_weak_ptr(); } // Forward declarations. template class __shared_ptr; template class __weak_ptr; template class __enable_shared_from_this; template class shared_ptr; template class weak_ptr; template class enable_shared_from_this; // Support for enable_shared_from_this. // Friend of __enable_shared_from_this. template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> void __enable_shared_from_this_helper(const __shared_count<_Lp>&, const __enable_shared_from_this<_Tp1, _Lp>*, const _Tp2*); // Friend of enable_shared_from_this. template void __enable_shared_from_this_helper(const __shared_count<>&, const enable_shared_from_this<_Tp1>*, const _Tp2*); template<_Lock_policy _Lp> inline void __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) { } struct __static_cast_tag { }; struct __const_cast_tag { }; struct __dynamic_cast_tag { }; // A smart pointer with reference-counted copy semantics. The // object pointed to is deleted when the last shared_ptr pointing to // it is destroyed or reset. template class __shared_ptr { public: typedef _Tp element_type; __shared_ptr() : _M_ptr(0), _M_refcount() // never throws { } template explicit __shared_ptr(_Tp1* __p) : _M_ptr(__p), _M_refcount(__p) { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) typedef int _IsComplete[sizeof(_Tp1)]; __enable_shared_from_this_helper(_M_refcount, __p, __p); } template __shared_ptr(_Tp1* __p, _Deleter __d) : _M_ptr(__p), _M_refcount(__p, __d) { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) // TODO requires _Deleter CopyConstructible and __d(__p) well-formed __enable_shared_from_this_helper(_M_refcount, __p, __p); } // generated copy constructor, assignment, destructor are fine. template __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } template explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) : _M_refcount(__r._M_refcount) // may throw { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount) // did not throw. _M_ptr = __r._M_ptr; } #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED // Postcondition: use_count() == 1 and __r.get() == 0 template explicit __shared_ptr(std::auto_ptr<_Tp1>& __r) : _M_ptr(__r.get()), _M_refcount() { // TODO requries delete __r.release() well-formed __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) typedef int _IsComplete[sizeof(_Tp1)]; _Tp1* __tmp = __r.get(); _M_refcount = __shared_count<_Lp>(__r); __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); } #endif template __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag) : _M_ptr(static_cast(__r._M_ptr)), _M_refcount(__r._M_refcount) { } template __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag) : _M_ptr(const_cast(__r._M_ptr)), _M_refcount(__r._M_refcount) { } template __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag) : _M_ptr(dynamic_cast(__r._M_ptr)), _M_refcount(__r._M_refcount) { if (_M_ptr == 0) // need to allocate new counter -- the cast failed _M_refcount = __shared_count<_Lp>(); } template __shared_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw return *this; } #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED template __shared_ptr& operator=(std::auto_ptr<_Tp1>& __r) { __shared_ptr(__r).swap(*this); return *this; } #endif void reset() // never throws { __shared_ptr().swap(*this); } template void reset(_Tp1* __p) // _Tp1 must be complete. { // Catch self-reset errors. _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); __shared_ptr(__p).swap(*this); } template void reset(_Tp1* __p, _Deleter __d) { __shared_ptr(__p, __d).swap(*this); } // Allow class instantiation when _Tp is [cv-qual] void. typename std::tr1::add_reference<_Tp>::type operator*() const // never throws { _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); return *_M_ptr; } _Tp* operator->() const // never throws { _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); return _M_ptr; } _Tp* get() const // never throws { return _M_ptr; } // Implicit conversion to "bool" private: typedef _Tp* __shared_ptr::*__unspecified_bool_type; public: operator __unspecified_bool_type() const // never throws { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } bool unique() const // never throws { return _M_refcount._M_unique(); } long use_count() const // never throws { return _M_refcount._M_get_use_count(); } void swap(__shared_ptr<_Tp, _Lp>& __other) // never throws { std::swap(_M_ptr, __other._M_ptr); _M_refcount._M_swap(__other._M_refcount); } private: void* _M_get_deleter(const std::type_info& __ti) const { return _M_refcount._M_get_deleter(__ti); } template bool _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const { return _M_refcount < __rhs._M_refcount; } template friend class __shared_ptr; template friend class __weak_ptr; template friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); // Friends injected into enclosing namespace and found by ADL: template friend inline bool operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) { return __a.get() == __b.get(); } template friend inline bool operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) { return __a.get() != __b.get(); } template friend inline bool operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) { return __a._M_less(__b); } _Tp* _M_ptr; // Contained pointer. __shared_count<_Lp> _M_refcount; // Reference counter. }; // 2.2.3.8 shared_ptr specialized algorithms. template inline void swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) { __a.swap(__b); } // 2.2.3.9 shared_ptr casts /* The seemingly equivalent * shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get())) * will eventually result in undefined behaviour, * attempting to delete the same object twice. */ template inline __shared_ptr<_Tp, _Lp> static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); } /* The seemingly equivalent * shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get())) * will eventually result in undefined behaviour, * attempting to delete the same object twice. */ template inline __shared_ptr<_Tp, _Lp> const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); } /* The seemingly equivalent * shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get())) * will eventually result in undefined behaviour, * attempting to delete the same object twice. */ template inline __shared_ptr<_Tp, _Lp> dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); } // 2.2.3.7 shared_ptr I/O template std::basic_ostream<_Ch, _Tr>& operator<<(std::basic_ostream<_Ch, _Tr>& __os, const __shared_ptr<_Tp, _Lp>& __p) { __os << __p.get(); return __os; } // 2.2.3.10 shared_ptr get_deleter (experimental) template inline _Del* get_deleter(const __shared_ptr<_Tp, _Lp>& __p) { #if __cpp_rtti return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); #else return 0; #endif } template class __weak_ptr { public: typedef _Tp element_type; __weak_ptr() : _M_ptr(0), _M_refcount() // never throws { } // Generated copy constructor, assignment, destructor are fine. // The "obvious" converting constructor implementation: // // template // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws // { } // // has a serious problem. // // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr) // conversion may require access to *__r._M_ptr (virtual inheritance). // // It is not possible to avoid spurious access violations since // in multithreaded programs __r._M_ptr may be invalidated at any point. template __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) : _M_refcount(__r._M_refcount) // never throws { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) _M_ptr = __r.lock().get(); } template __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } template __weak_ptr& operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws { _M_ptr = __r.lock().get(); _M_refcount = __r._M_refcount; return *this; } template __weak_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } __shared_ptr<_Tp, _Lp> lock() const // never throws { #ifdef __GTHREADS // Optimization: avoid throw overhead. if (expired()) return __shared_ptr(); __try { return __shared_ptr(*this); } __catch(const bad_weak_ptr&) { // Q: How can we get here? // A: Another thread may have invalidated r after the // use_count test above. return __shared_ptr(); } #else // Optimization: avoid try/catch overhead when single threaded. return expired() ? __shared_ptr() : __shared_ptr(*this); #endif } // XXX MT long use_count() const // never throws { return _M_refcount._M_get_use_count(); } bool expired() const // never throws { return _M_refcount._M_get_use_count() == 0; } void reset() // never throws { __weak_ptr().swap(*this); } void swap(__weak_ptr& __s) // never throws { std::swap(_M_ptr, __s._M_ptr); _M_refcount._M_swap(__s._M_refcount); } private: // Used by __enable_shared_from_this. void _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) { _M_ptr = __ptr; _M_refcount = __refcount; } template bool _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const { return _M_refcount < __rhs._M_refcount; } template friend class __shared_ptr; template friend class __weak_ptr; friend class __enable_shared_from_this<_Tp, _Lp>; friend class enable_shared_from_this<_Tp>; // Friend injected into namespace and found by ADL. template friend inline bool operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs) { return __lhs._M_less(__rhs); } _Tp* _M_ptr; // Contained pointer. __weak_count<_Lp> _M_refcount; // Reference counter. }; // 2.2.4.7 weak_ptr specialized algorithms. template inline void swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) { __a.swap(__b); } template class __enable_shared_from_this { protected: __enable_shared_from_this() { } __enable_shared_from_this(const __enable_shared_from_this&) { } __enable_shared_from_this& operator=(const __enable_shared_from_this&) { return *this; } ~__enable_shared_from_this() { } public: __shared_ptr<_Tp, _Lp> shared_from_this() { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } __shared_ptr shared_from_this() const { return __shared_ptr(this->_M_weak_this); } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const { _M_weak_this._M_assign(__p, __n); } template friend void __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn, const __enable_shared_from_this* __pe, const _Tp1* __px) { if (__pe != 0) __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); } mutable __weak_ptr<_Tp, _Lp> _M_weak_this; }; // The actual shared_ptr, with forwarding constructors and // assignment operators. template class shared_ptr : public __shared_ptr<_Tp> { public: shared_ptr() : __shared_ptr<_Tp>() { } template explicit shared_ptr(_Tp1* __p) : __shared_ptr<_Tp>(__p) { } template shared_ptr(_Tp1* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, __d) { } template shared_ptr(const shared_ptr<_Tp1>& __r) : __shared_ptr<_Tp>(__r) { } template explicit shared_ptr(const weak_ptr<_Tp1>& __r) : __shared_ptr<_Tp>(__r) { } #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED template explicit shared_ptr(std::auto_ptr<_Tp1>& __r) : __shared_ptr<_Tp>(__r) { } #endif template shared_ptr(const shared_ptr<_Tp1>& __r, __static_cast_tag) : __shared_ptr<_Tp>(__r, __static_cast_tag()) { } template shared_ptr(const shared_ptr<_Tp1>& __r, __const_cast_tag) : __shared_ptr<_Tp>(__r, __const_cast_tag()) { } template shared_ptr(const shared_ptr<_Tp1>& __r, __dynamic_cast_tag) : __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { } template shared_ptr& operator=(const shared_ptr<_Tp1>& __r) // never throws { this->__shared_ptr<_Tp>::operator=(__r); return *this; } #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED template shared_ptr& operator=(std::auto_ptr<_Tp1>& __r) { this->__shared_ptr<_Tp>::operator=(__r); return *this; } #endif }; // 2.2.3.8 shared_ptr specialized algorithms. template inline void swap(__shared_ptr<_Tp>& __a, __shared_ptr<_Tp>& __b) { __a.swap(__b); } template inline shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Tp1>& __r) { return shared_ptr<_Tp>(__r, __static_cast_tag()); } template inline shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Tp1>& __r) { return shared_ptr<_Tp>(__r, __const_cast_tag()); } template inline shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) { return shared_ptr<_Tp>(__r, __dynamic_cast_tag()); } // The actual weak_ptr, with forwarding constructors and // assignment operators. template class weak_ptr : public __weak_ptr<_Tp> { public: weak_ptr() : __weak_ptr<_Tp>() { } template weak_ptr(const weak_ptr<_Tp1>& __r) : __weak_ptr<_Tp>(__r) { } template weak_ptr(const shared_ptr<_Tp1>& __r) : __weak_ptr<_Tp>(__r) { } template weak_ptr& operator=(const weak_ptr<_Tp1>& __r) // never throws { this->__weak_ptr<_Tp>::operator=(__r); return *this; } template weak_ptr& operator=(const shared_ptr<_Tp1>& __r) // never throws { this->__weak_ptr<_Tp>::operator=(__r); return *this; } shared_ptr<_Tp> lock() const // never throws { #ifdef __GTHREADS if (this->expired()) return shared_ptr<_Tp>(); __try { return shared_ptr<_Tp>(*this); } __catch(const bad_weak_ptr&) { return shared_ptr<_Tp>(); } #else return this->expired() ? shared_ptr<_Tp>() : shared_ptr<_Tp>(*this); #endif } }; template class enable_shared_from_this { protected: enable_shared_from_this() { } enable_shared_from_this(const enable_shared_from_this&) { } enable_shared_from_this& operator=(const enable_shared_from_this&) { return *this; } ~enable_shared_from_this() { } public: shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(this->_M_weak_this); } shared_ptr shared_from_this() const { return shared_ptr(this->_M_weak_this); } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const { _M_weak_this._M_assign(__p, __n); } template friend void __enable_shared_from_this_helper(const __shared_count<>& __pn, const enable_shared_from_this* __pe, const _Tp1* __px) { if (__pe != 0) __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); } mutable weak_ptr<_Tp> _M_weak_this; }; } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _TR1_SHARED_PTR_H c++/8/tr1/unordered_set.h000064400000022504152640040210011001 0ustar00// TR1 unordered_set implementation -*- C++ -*- // Copyright (C) 2010-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/unordered_set.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/unordered_set} */ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { // NB: When we get typedef templates these class definitions // will be unnecessary. template, class _Pred = std::equal_to<_Value>, class _Alloc = std::allocator<_Value>, bool __cache_hash_code = false> class __unordered_set : public _Hashtable<_Value, _Value, _Alloc, std::_Identity<_Value>, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, true, true> { typedef _Hashtable<_Value, _Value, _Alloc, std::_Identity<_Value>, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, true, true> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit __unordered_set(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Identity<_Value>(), __a) { } template __unordered_set(_InputIterator __f, _InputIterator __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Identity<_Value>(), __a) { } }; template, class _Pred = std::equal_to<_Value>, class _Alloc = std::allocator<_Value>, bool __cache_hash_code = false> class __unordered_multiset : public _Hashtable<_Value, _Value, _Alloc, std::_Identity<_Value>, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, true, false> { typedef _Hashtable<_Value, _Value, _Alloc, std::_Identity<_Value>, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, __cache_hash_code, true, false> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit __unordered_multiset(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Identity<_Value>(), __a) { } template __unordered_multiset(_InputIterator __f, _InputIterator __l, typename _Base::size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(), __detail::_Default_ranged_hash(), __eql, std::_Identity<_Value>(), __a) { } }; template inline void swap(__unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x, __unordered_set<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y) { __x.swap(__y); } template inline void swap(__unordered_multiset<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __x, __unordered_multiset<_Value, _Hash, _Pred, _Alloc, __cache_hash_code>& __y) { __x.swap(__y); } /** * @brief A standard container composed of unique keys (containing * at most one of each key value) in which the elements' keys are * the elements themselves. * * @ingroup unordered_associative_containers * * Meets the requirements of a container, and * unordered associative container * * @param Value Type of key objects. * @param Hash Hashing function object type, defaults to hash. * @param Pred Predicate function object type, defaults to equal_to. * @param Alloc Allocator type, defaults to allocator. */ template, class _Pred = std::equal_to<_Value>, class _Alloc = std::allocator<_Value> > class unordered_set : public __unordered_set<_Value, _Hash, _Pred, _Alloc> { typedef __unordered_set<_Value, _Hash, _Pred, _Alloc> _Base; public: typedef typename _Base::value_type value_type; typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit unordered_set(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_set(_InputIterator __f, _InputIterator __l, size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } }; /** * @brief A standard container composed of equivalent keys * (possibly containing multiple of each key value) in which the * elements' keys are the elements themselves. * * @ingroup unordered_associative_containers * * Meets the requirements of a container, and * unordered associative container * * @param Value Type of key objects. * @param Hash Hashing function object type, defaults to hash. * @param Pred Predicate function object type, defaults to equal_to. * @param Alloc Allocator type, defaults to allocator. */ template, class _Pred = std::equal_to<_Value>, class _Alloc = std::allocator<_Value> > class unordered_multiset : public __unordered_multiset<_Value, _Hash, _Pred, _Alloc> { typedef __unordered_multiset<_Value, _Hash, _Pred, _Alloc> _Base; public: typedef typename _Base::value_type value_type; typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; explicit unordered_multiset(size_type __n = 10, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_multiset(_InputIterator __f, _InputIterator __l, typename _Base::size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } }; template inline void swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) { __x.swap(__y); } template inline void swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) { __x.swap(__y); } } _GLIBCXX_END_NAMESPACE_VERSION } c++/8/tr1/cstdbool000064400000002500152640040210007514 0ustar00// TR1 cstdbool -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cstdbool * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CSTDBOOL #define _GLIBCXX_TR1_CSTDBOOL 1 #pragma GCC system_header #include #if _GLIBCXX_HAVE_STDBOOL_H #include #endif #endif // _GLIBCXX_TR1_CSTDBOOL c++/8/tr1/stdint.h000064400000002276152640040210007450 0ustar00// TR1 stdint.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/stdint.h * This is a TR1 C++ Library header. */ #ifndef _TR1_STDINT_H #define _TR1_STDINT_H 1 #include #endif c++/8/tr1/memory000064400000003377152640040210007230 0ustar00// -*- C++ -*- // Copyright (C) 2005-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** * @file tr1/memory * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_MEMORY #define _GLIBCXX_TR1_MEMORY 1 #pragma GCC system_header #if defined(_GLIBCXX_INCLUDE_AS_CXX11) # error TR1 header cannot be included from C++11 header #endif #include #include // std::exception #include // std::type_info in get_deleter #include // std::swap #include // std::basic_ostream #include #include #include #include // std::less #include #include #include #endif // _GLIBCXX_TR1_MEMORY c++/8/tr1/cstdio000064400000002712152640040210007175 0ustar00// TR1 cstdio -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cstdio * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CSTDIO #define _GLIBCXX_TR1_CSTDIO 1 #pragma GCC system_header #include #if _GLIBCXX_USE_C99_STDIO namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { using std::snprintf; using std::vsnprintf; using std::vfscanf; using std::vscanf; using std::vsscanf; } } #endif #endif // _GLIBCXX_TR1_CSTDIO c++/8/tr1/bessel_function.tcc000064400000053711152640040210011647 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/bessel_function.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland. // // References: // (1) Handbook of Mathematical Functions, // ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 9, pp. 355-434, Section 10 pp. 435-478 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 240-245 #ifndef _GLIBCXX_TR1_BESSEL_FUNCTION_TCC #define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1 #include "special_function_util.h" namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS # define _GLIBCXX_MATH_NS ::std #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { # define _GLIBCXX_MATH_NS ::std::tr1 #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Compute the gamma functions required by the Temme series * expansions of @f$ N_\nu(x) @f$ and @f$ K_\nu(x) @f$. * @f[ * \Gamma_1 = \frac{1}{2\mu} * [\frac{1}{\Gamma(1 - \mu)} - \frac{1}{\Gamma(1 + \mu)}] * @f] * and * @f[ * \Gamma_2 = \frac{1}{2} * [\frac{1}{\Gamma(1 - \mu)} + \frac{1}{\Gamma(1 + \mu)}] * @f] * where @f$ -1/2 <= \mu <= 1/2 @f$ is @f$ \mu = \nu - N @f$ and @f$ N @f$. * is the nearest integer to @f$ \nu @f$. * The values of \f$ \Gamma(1 + \mu) \f$ and \f$ \Gamma(1 - \mu) \f$ * are returned as well. * * The accuracy requirements on this are exquisite. * * @param __mu The input parameter of the gamma functions. * @param __gam1 The output function \f$ \Gamma_1(\mu) \f$ * @param __gam2 The output function \f$ \Gamma_2(\mu) \f$ * @param __gampl The output function \f$ \Gamma(1 + \mu) \f$ * @param __gammi The output function \f$ \Gamma(1 - \mu) \f$ */ template void __gamma_temme(_Tp __mu, _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) { #if _GLIBCXX_USE_C99_MATH_TR1 __gampl = _Tp(1) / _GLIBCXX_MATH_NS::tgamma(_Tp(1) + __mu); __gammi = _Tp(1) / _GLIBCXX_MATH_NS::tgamma(_Tp(1) - __mu); #else __gampl = _Tp(1) / __gamma(_Tp(1) + __mu); __gammi = _Tp(1) / __gamma(_Tp(1) - __mu); #endif if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); else __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); __gam2 = (__gammi + __gampl) / (_Tp(2)); return; } /** * @brief Compute the Bessel @f$ J_\nu(x) @f$ and Neumann * @f$ N_\nu(x) @f$ functions and their first derivatives * @f$ J'_\nu(x) @f$ and @f$ N'_\nu(x) @f$ respectively. * These four functions are computed together for numerical * stability. * * @param __nu The order of the Bessel functions. * @param __x The argument of the Bessel functions. * @param __Jnu The output Bessel function of the first kind. * @param __Nnu The output Neumann function (Bessel function of the second kind). * @param __Jpnu The output derivative of the Bessel function of the first kind. * @param __Npnu The output derivative of the Neumann function. */ template void __bessel_jn(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) { if (__x == _Tp(0)) { if (__nu == _Tp(0)) { __Jnu = _Tp(1); __Jpnu = _Tp(0); } else if (__nu == _Tp(1)) { __Jnu = _Tp(0); __Jpnu = _Tp(0.5L); } else { __Jnu = _Tp(0); __Jpnu = _Tp(0); } __Nnu = -std::numeric_limits<_Tp>::infinity(); __Npnu = std::numeric_limits<_Tp>::infinity(); return; } const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); // When the multiplier is N i.e. // fp_min = N * min() // Then J_0 and N_0 tank at x = 8 * N (J_0 = 0 and N_0 = nan)! //const _Tp __fp_min = _Tp(20) * std::numeric_limits<_Tp>::min(); const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); const int __max_iter = 15000; const _Tp __x_min = _Tp(2); const int __nl = (__x < __x_min ? static_cast(__nu + _Tp(0.5L)) : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); const _Tp __mu = __nu - __nl; const _Tp __mu2 = __mu * __mu; const _Tp __xi = _Tp(1) / __x; const _Tp __xi2 = _Tp(2) * __xi; _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); int __isign = 1; _Tp __h = __nu * __xi; if (__h < __fp_min) __h = __fp_min; _Tp __b = __xi2 * __nu; _Tp __d = _Tp(0); _Tp __c = __h; int __i; for (__i = 1; __i <= __max_iter; ++__i) { __b += __xi2; __d = __b - __d; if (std::abs(__d) < __fp_min) __d = __fp_min; __c = __b - _Tp(1) / __c; if (std::abs(__c) < __fp_min) __c = __fp_min; __d = _Tp(1) / __d; const _Tp __del = __c * __d; __h *= __del; if (__d < _Tp(0)) __isign = -__isign; if (std::abs(__del - _Tp(1)) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(__N("Argument x too large in __bessel_jn; " "try asymptotic expansion.")); _Tp __Jnul = __isign * __fp_min; _Tp __Jpnul = __h * __Jnul; _Tp __Jnul1 = __Jnul; _Tp __Jpnu1 = __Jpnul; _Tp __fact = __nu * __xi; for ( int __l = __nl; __l >= 1; --__l ) { const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; __fact -= __xi; __Jpnul = __fact * __Jnutemp - __Jnul; __Jnul = __Jnutemp; } if (__Jnul == _Tp(0)) __Jnul = __eps; _Tp __f= __Jpnul / __Jnul; _Tp __Nmu, __Nnu1, __Npmu, __Jmu; if (__x < __x_min) { const _Tp __x2 = __x / _Tp(2); const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; _Tp __fact = (std::abs(__pimu) < __eps ? _Tp(1) : __pimu / std::sin(__pimu)); _Tp __d = -std::log(__x2); _Tp __e = __mu * __d; _Tp __fact2 = (std::abs(__e) < __eps ? _Tp(1) : std::sinh(__e) / __e); _Tp __gam1, __gam2, __gampl, __gammi; __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); __e = std::exp(__e); _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); const _Tp __pimu2 = __pimu / _Tp(2); _Tp __fact3 = (std::abs(__pimu2) < __eps ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; _Tp __c = _Tp(1); __d = -__x2 * __x2; _Tp __sum = __ff + __r * __q; _Tp __sum1 = __p; for (__i = 1; __i <= __max_iter; ++__i) { __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); __c *= __d / _Tp(__i); __p /= _Tp(__i) - __mu; __q /= _Tp(__i) + __mu; const _Tp __del = __c * (__ff + __r * __q); __sum += __del; const _Tp __del1 = __c * __p - __i * __del; __sum1 += __del1; if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) break; } if ( __i > __max_iter ) std::__throw_runtime_error(__N("Bessel y series failed to converge " "in __bessel_jn.")); __Nmu = -__sum; __Nnu1 = -__sum1 * __xi2; __Npmu = __mu * __xi * __Nmu - __Nnu1; __Jmu = __w / (__Npmu - __f * __Nmu); } else { _Tp __a = _Tp(0.25L) - __mu2; _Tp __q = _Tp(1); _Tp __p = -__xi / _Tp(2); _Tp __br = _Tp(2) * __x; _Tp __bi = _Tp(2); _Tp __fact = __a * __xi / (__p * __p + __q * __q); _Tp __cr = __br + __q * __fact; _Tp __ci = __bi + __p * __fact; _Tp __den = __br * __br + __bi * __bi; _Tp __dr = __br / __den; _Tp __di = -__bi / __den; _Tp __dlr = __cr * __dr - __ci * __di; _Tp __dli = __cr * __di + __ci * __dr; _Tp __temp = __p * __dlr - __q * __dli; __q = __p * __dli + __q * __dlr; __p = __temp; int __i; for (__i = 2; __i <= __max_iter; ++__i) { __a += _Tp(2 * (__i - 1)); __bi += _Tp(2); __dr = __a * __dr + __br; __di = __a * __di + __bi; if (std::abs(__dr) + std::abs(__di) < __fp_min) __dr = __fp_min; __fact = __a / (__cr * __cr + __ci * __ci); __cr = __br + __cr * __fact; __ci = __bi - __ci * __fact; if (std::abs(__cr) + std::abs(__ci) < __fp_min) __cr = __fp_min; __den = __dr * __dr + __di * __di; __dr /= __den; __di /= -__den; __dlr = __cr * __dr - __ci * __di; __dli = __cr * __di + __ci * __dr; __temp = __p * __dlr - __q * __dli; __q = __p * __dli + __q * __dlr; __p = __temp; if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(__N("Lentz's method failed " "in __bessel_jn.")); const _Tp __gam = (__p - __f) / __q; __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); #if _GLIBCXX_USE_C99_MATH_TR1 __Jmu = _GLIBCXX_MATH_NS::copysign(__Jmu, __Jnul); #else if (__Jmu * __Jnul < _Tp(0)) __Jmu = -__Jmu; #endif __Nmu = __gam * __Jmu; __Npmu = (__p + __q / __gam) * __Nmu; __Nnu1 = __mu * __xi * __Nmu - __Npmu; } __fact = __Jmu / __Jnul; __Jnu = __fact * __Jnul1; __Jpnu = __fact * __Jpnu1; for (__i = 1; __i <= __nl; ++__i) { const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; __Nmu = __Nnu1; __Nnu1 = __Nnutemp; } __Nnu = __Nmu; __Npnu = __nu * __xi * __Nmu - __Nnu1; return; } /** * @brief This routine computes the asymptotic cylindrical Bessel * and Neumann functions of order nu: \f$ J_{\nu} \f$, * \f$ N_{\nu} \f$. * * References: * (1) Handbook of Mathematical Functions, * ed. Milton Abramowitz and Irene A. Stegun, * Dover Publications, * Section 9 p. 364, Equations 9.2.5-9.2.10 * * @param __nu The order of the Bessel functions. * @param __x The argument of the Bessel functions. * @param __Jnu The output Bessel function of the first kind. * @param __Nnu The output Neumann function (Bessel function of the second kind). */ template void __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) { const _Tp __mu = _Tp(4) * __nu * __nu; const _Tp __mum1 = __mu - _Tp(1); const _Tp __mum9 = __mu - _Tp(9); const _Tp __mum25 = __mu - _Tp(25); const _Tp __mum49 = __mu - _Tp(49); const _Tp __xx = _Tp(64) * __x * __x; const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx) * (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx)); const _Tp __Q = __mum1 / (_Tp(8) * __x) * (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx)); const _Tp __chi = __x - (__nu + _Tp(0.5L)) * __numeric_constants<_Tp>::__pi_2(); const _Tp __c = std::cos(__chi); const _Tp __s = std::sin(__chi); const _Tp __coef = std::sqrt(_Tp(2) / (__numeric_constants<_Tp>::__pi() * __x)); __Jnu = __coef * (__c * __P - __s * __Q); __Nnu = __coef * (__s * __P + __c * __Q); return; } /** * @brief This routine returns the cylindrical Bessel functions * of order \f$ \nu \f$: \f$ J_{\nu} \f$ or \f$ I_{\nu} \f$ * by series expansion. * * The modified cylindrical Bessel function is: * @f[ * Z_{\nu}(x) = \sum_{k=0}^{\infty} * \frac{\sigma^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)} * @f] * where \f$ \sigma = +1 \f$ or\f$ -1 \f$ for * \f$ Z = I \f$ or \f$ J \f$ respectively. * * See Abramowitz & Stegun, 9.1.10 * Abramowitz & Stegun, 9.6.7 * (1) Handbook of Mathematical Functions, * ed. Milton Abramowitz and Irene A. Stegun, * Dover Publications, * Equation 9.1.10 p. 360 and Equation 9.6.10 p. 375 * * @param __nu The order of the Bessel function. * @param __x The argument of the Bessel function. * @param __sgn The sign of the alternate terms * -1 for the Bessel function of the first kind. * +1 for the modified Bessel function of the first kind. * @return The output Bessel function. */ template _Tp __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, unsigned int __max_iter) { if (__x == _Tp(0)) return __nu == _Tp(0) ? _Tp(1) : _Tp(0); const _Tp __x2 = __x / _Tp(2); _Tp __fact = __nu * std::log(__x2); #if _GLIBCXX_USE_C99_MATH_TR1 __fact -= _GLIBCXX_MATH_NS::lgamma(__nu + _Tp(1)); #else __fact -= __log_gamma(__nu + _Tp(1)); #endif __fact = std::exp(__fact); const _Tp __xx4 = __sgn * __x2 * __x2; _Tp __Jn = _Tp(1); _Tp __term = _Tp(1); for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); __Jn += __term; if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) break; } return __fact * __Jn; } /** * @brief Return the Bessel function of order \f$ \nu \f$: * \f$ J_{\nu}(x) \f$. * * The cylindrical Bessel function is: * @f[ * J_{\nu}(x) = \sum_{k=0}^{\infty} * \frac{(-1)^k (x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)} * @f] * * @param __nu The order of the Bessel function. * @param __x The argument of the Bessel function. * @return The output Bessel function. */ template _Tp __cyl_bessel_j(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __cyl_bessel_j.")); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); else if (__x > _Tp(1000)) { _Tp __J_nu, __N_nu; __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); return __J_nu; } else { _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); return __J_nu; } } /** * @brief Return the Neumann function of order \f$ \nu \f$: * \f$ N_{\nu}(x) \f$. * * The Neumann function is defined by: * @f[ * N_{\nu}(x) = \frac{J_{\nu}(x) \cos \nu\pi - J_{-\nu}(x)} * {\sin \nu\pi} * @f] * where for integral \f$ \nu = n \f$ a limit is taken: * \f$ lim_{\nu \to n} \f$. * * @param __nu The order of the Neumann function. * @param __x The argument of the Neumann function. * @return The output Neumann function. */ template _Tp __cyl_neumann_n(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __cyl_neumann_n.")); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x > _Tp(1000)) { _Tp __J_nu, __N_nu; __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); return __N_nu; } else { _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); return __N_nu; } } /** * @brief Compute the spherical Bessel @f$ j_n(x) @f$ * and Neumann @f$ n_n(x) @f$ functions and their first * derivatives @f$ j'_n(x) @f$ and @f$ n'_n(x) @f$ * respectively. * * @param __n The order of the spherical Bessel function. * @param __x The argument of the spherical Bessel function. * @param __j_n The output spherical Bessel function. * @param __n_n The output spherical Neumann function. * @param __jp_n The output derivative of the spherical Bessel function. * @param __np_n The output derivative of the spherical Neumann function. */ template void __sph_bessel_jn(unsigned int __n, _Tp __x, _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) { const _Tp __nu = _Tp(__n) + _Tp(0.5L); _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() / std::sqrt(__x); __j_n = __factor * __J_nu; __n_n = __factor * __N_nu; __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); return; } /** * @brief Return the spherical Bessel function * @f$ j_n(x) @f$ of order n. * * The spherical Bessel function is defined by: * @f[ * j_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} J_{n+1/2}(x) * @f] * * @param __n The order of the spherical Bessel function. * @param __x The argument of the spherical Bessel function. * @return The output spherical Bessel function. */ template _Tp __sph_bessel(unsigned int __n, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __sph_bessel.")); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == _Tp(0)) { if (__n == 0) return _Tp(1); else return _Tp(0); } else { _Tp __j_n, __n_n, __jp_n, __np_n; __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); return __j_n; } } /** * @brief Return the spherical Neumann function * @f$ n_n(x) @f$. * * The spherical Neumann function is defined by: * @f[ * n_n(x) = \left( \frac{\pi}{2x} \right) ^{1/2} N_{n+1/2}(x) * @f] * * @param __n The order of the spherical Neumann function. * @param __x The argument of the spherical Neumann function. * @return The output spherical Neumann function. */ template _Tp __sph_neumann(unsigned int __n, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __sph_neumann.")); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == _Tp(0)) return -std::numeric_limits<_Tp>::infinity(); else { _Tp __j_n, __n_n, __jp_n, __np_n; __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); return __n_n; } } } // namespace __detail #undef _GLIBCXX_MATH_NS #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC c++/8/tr1/cfloat000064400000002544152640040210007163 0ustar00// TR1 cfloat -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cfloat * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CFLOAT #define _GLIBCXX_TR1_CFLOAT 1 #include #ifndef DECIMAL_DIG #define DECIMAL_DIG __DECIMAL_DIG__ #endif #ifndef FLT_EVAL_METHOD #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ #endif #endif //_GLIBCXX_TR1_CFLOAT c++/8/tr1/cfenv000064400000003724152640040210007015 0ustar00// TR1 cfenv -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cfenv * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CFENV #define _GLIBCXX_TR1_CFENV 1 #pragma GCC system_header #include #if _GLIBCXX_HAVE_FENV_H # include #endif #ifdef _GLIBCXX_USE_C99_FENV_TR1 #undef feclearexcept #undef fegetexceptflag #undef feraiseexcept #undef fesetexceptflag #undef fetestexcept #undef fegetround #undef fesetround #undef fegetenv #undef feholdexcept #undef fesetenv #undef feupdateenv namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { // types using ::fenv_t; using ::fexcept_t; // functions using ::feclearexcept; using ::fegetexceptflag; using ::feraiseexcept; using ::fesetexceptflag; using ::fetestexcept; using ::fegetround; using ::fesetround; using ::fegetenv; using ::feholdexcept; using ::fesetenv; using ::feupdateenv; } } #endif // _GLIBCXX_USE_C99_FENV_TR1 #endif // _GLIBCXX_TR1_CFENV c++/8/tr1/limits.h000064400000002276152640040210007444 0ustar00// TR1 limits.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/limits.h * This is a TR1 C++ Library header. */ #ifndef _TR1_LIMITS_H #define _TR1_LIMITS_H 1 #include #endif c++/8/tr1/random000064400000003065152640040210007172 0ustar00// random number generation -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** * @file tr1/random * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_RANDOM #define _GLIBCXX_TR1_RANDOM 1 #pragma GCC system_header #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // _GLIBCXX_TR1_RANDOM c++/8/tr1/modified_bessel_func.tcc000064400000037700152640040210012615 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/modified_bessel_func.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland. // // References: // (1) Handbook of Mathematical Functions, // Ed. Milton Abramowitz and Irene A. Stegun, // Dover Publications, // Section 9, pp. 355-434, Section 10 pp. 435-478 // (2) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (3) Numerical Recipes in C, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press (1992), // 2nd ed, pp. 246-249. #ifndef _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC #define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1 #include "special_function_util.h" namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Compute the modified Bessel functions @f$ I_\nu(x) @f$ and * @f$ K_\nu(x) @f$ and their first derivatives * @f$ I'_\nu(x) @f$ and @f$ K'_\nu(x) @f$ respectively. * These four functions are computed together for numerical * stability. * * @param __nu The order of the Bessel functions. * @param __x The argument of the Bessel functions. * @param __Inu The output regular modified Bessel function. * @param __Knu The output irregular modified Bessel function. * @param __Ipnu The output derivative of the regular * modified Bessel function. * @param __Kpnu The output derivative of the irregular * modified Bessel function. */ template void __bessel_ik(_Tp __nu, _Tp __x, _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) { if (__x == _Tp(0)) { if (__nu == _Tp(0)) { __Inu = _Tp(1); __Ipnu = _Tp(0); } else if (__nu == _Tp(1)) { __Inu = _Tp(0); __Ipnu = _Tp(0.5L); } else { __Inu = _Tp(0); __Ipnu = _Tp(0); } __Knu = std::numeric_limits<_Tp>::infinity(); __Kpnu = -std::numeric_limits<_Tp>::infinity(); return; } const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); const int __max_iter = 15000; const _Tp __x_min = _Tp(2); const int __nl = static_cast(__nu + _Tp(0.5L)); const _Tp __mu = __nu - __nl; const _Tp __mu2 = __mu * __mu; const _Tp __xi = _Tp(1) / __x; const _Tp __xi2 = _Tp(2) * __xi; _Tp __h = __nu * __xi; if ( __h < __fp_min ) __h = __fp_min; _Tp __b = __xi2 * __nu; _Tp __d = _Tp(0); _Tp __c = __h; int __i; for ( __i = 1; __i <= __max_iter; ++__i ) { __b += __xi2; __d = _Tp(1) / (__b + __d); __c = __b + _Tp(1) / __c; const _Tp __del = __c * __d; __h *= __del; if (std::abs(__del - _Tp(1)) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(__N("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.")); _Tp __Inul = __fp_min; _Tp __Ipnul = __h * __Inul; _Tp __Inul1 = __Inul; _Tp __Ipnu1 = __Ipnul; _Tp __fact = __nu * __xi; for (int __l = __nl; __l >= 1; --__l) { const _Tp __Inutemp = __fact * __Inul + __Ipnul; __fact -= __xi; __Ipnul = __fact * __Inutemp + __Inul; __Inul = __Inutemp; } _Tp __f = __Ipnul / __Inul; _Tp __Kmu, __Knu1; if (__x < __x_min) { const _Tp __x2 = __x / _Tp(2); const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; const _Tp __fact = (std::abs(__pimu) < __eps ? _Tp(1) : __pimu / std::sin(__pimu)); _Tp __d = -std::log(__x2); _Tp __e = __mu * __d; const _Tp __fact2 = (std::abs(__e) < __eps ? _Tp(1) : std::sinh(__e) / __e); _Tp __gam1, __gam2, __gampl, __gammi; __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); _Tp __ff = __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); _Tp __sum = __ff; __e = std::exp(__e); _Tp __p = __e / (_Tp(2) * __gampl); _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); _Tp __c = _Tp(1); __d = __x2 * __x2; _Tp __sum1 = __p; int __i; for (__i = 1; __i <= __max_iter; ++__i) { __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); __c *= __d / __i; __p /= __i - __mu; __q /= __i + __mu; const _Tp __del = __c * __ff; __sum += __del; const _Tp __del1 = __c * (__p - __i * __ff); __sum1 += __del1; if (std::abs(__del) < __eps * std::abs(__sum)) break; } if (__i > __max_iter) std::__throw_runtime_error(__N("Bessel k series failed to converge " "in __bessel_ik.")); __Kmu = __sum; __Knu1 = __sum1 * __xi2; } else { _Tp __b = _Tp(2) * (_Tp(1) + __x); _Tp __d = _Tp(1) / __b; _Tp __delh = __d; _Tp __h = __delh; _Tp __q1 = _Tp(0); _Tp __q2 = _Tp(1); _Tp __a1 = _Tp(0.25L) - __mu2; _Tp __q = __c = __a1; _Tp __a = -__a1; _Tp __s = _Tp(1) + __q * __delh; int __i; for (__i = 2; __i <= __max_iter; ++__i) { __a -= 2 * (__i - 1); __c = -__a * __c / __i; const _Tp __qnew = (__q1 - __b * __q2) / __a; __q1 = __q2; __q2 = __qnew; __q += __c * __qnew; __b += _Tp(2); __d = _Tp(1) / (__b + __a * __d); __delh = (__b * __d - _Tp(1)) * __delh; __h += __delh; const _Tp __dels = __q * __delh; __s += __dels; if ( std::abs(__dels / __s) < __eps ) break; } if (__i > __max_iter) std::__throw_runtime_error(__N("Steed's method failed " "in __bessel_ik.")); __h = __a1 * __h; __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) * std::exp(-__x) / __s; __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; } _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); __Inu = __Inumu * __Inul1 / __Inul; __Ipnu = __Inumu * __Ipnu1 / __Inul; for ( __i = 1; __i <= __nl; ++__i ) { const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; __Kmu = __Knu1; __Knu1 = __Knutemp; } __Knu = __Kmu; __Kpnu = __nu * __xi * __Kmu - __Knu1; return; } /** * @brief Return the regular modified Bessel function of order * \f$ \nu \f$: \f$ I_{\nu}(x) \f$. * * The regular modified cylindrical Bessel function is: * @f[ * I_{\nu}(x) = \sum_{k=0}^{\infty} * \frac{(x/2)^{\nu + 2k}}{k!\Gamma(\nu+k+1)} * @f] * * @param __nu The order of the regular modified Bessel function. * @param __x The argument of the regular modified Bessel function. * @return The output regular modified Bessel function. */ template _Tp __cyl_bessel_i(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __cyl_bessel_i.")); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); else { _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); return __I_nu; } } /** * @brief Return the irregular modified Bessel function * \f$ K_{\nu}(x) \f$ of order \f$ \nu \f$. * * The irregular modified Bessel function is defined by: * @f[ * K_{\nu}(x) = \frac{\pi}{2} * \frac{I_{-\nu}(x) - I_{\nu}(x)}{\sin \nu\pi} * @f] * where for integral \f$ \nu = n \f$ a limit is taken: * \f$ lim_{\nu \to n} \f$. * * @param __nu The order of the irregular modified Bessel function. * @param __x The argument of the irregular modified Bessel function. * @return The output irregular modified Bessel function. */ template _Tp __cyl_bessel_k(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(__N("Bad argument " "in __cyl_bessel_k.")); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else { _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); return __K_nu; } } /** * @brief Compute the spherical modified Bessel functions * @f$ i_n(x) @f$ and @f$ k_n(x) @f$ and their first * derivatives @f$ i'_n(x) @f$ and @f$ k'_n(x) @f$ * respectively. * * @param __n The order of the modified spherical Bessel function. * @param __x The argument of the modified spherical Bessel function. * @param __i_n The output regular modified spherical Bessel function. * @param __k_n The output irregular modified spherical * Bessel function. * @param __ip_n The output derivative of the regular modified * spherical Bessel function. * @param __kp_n The output derivative of the irregular modified * spherical Bessel function. */ template void __sph_bessel_ik(unsigned int __n, _Tp __x, _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) { const _Tp __nu = _Tp(__n) + _Tp(0.5L); _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() / std::sqrt(__x); __i_n = __factor * __I_nu; __k_n = __factor * __K_nu; __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); return; } /** * @brief Compute the Airy functions * @f$ Ai(x) @f$ and @f$ Bi(x) @f$ and their first * derivatives @f$ Ai'(x) @f$ and @f$ Bi(x) @f$ * respectively. * * @param __x The argument of the Airy functions. * @param __Ai The output Airy function of the first kind. * @param __Bi The output Airy function of the second kind. * @param __Aip The output derivative of the Airy function * of the first kind. * @param __Bip The output derivative of the Airy function * of the second kind. */ template void __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) { const _Tp __absx = std::abs(__x); const _Tp __rootx = std::sqrt(__absx); const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN(); const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); if (__isnan(__x)) __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); else if (__z == _S_inf) { __Aip = __Ai = _Tp(0); __Bip = __Bi = _S_inf; } else if (__z == -_S_inf) __Bip = __Aip = __Bi = __Ai = _Tp(0); else if (__x > _Tp(0)) { _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); __Ai = __rootx * __K_nu / (__numeric_constants<_Tp>::__sqrt3() * __numeric_constants<_Tp>::__pi()); __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); __Aip = -__x * __K_nu / (__numeric_constants<_Tp>::__sqrt3() * __numeric_constants<_Tp>::__pi()); __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); } else if (__x < _Tp(0)) { _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); __Ai = __rootx * (__J_nu - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); __Bi = -__rootx * (__N_nu + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + __J_nu) / _Tp(2); __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() - __N_nu) / _Tp(2); } else { // Reference: // Abramowitz & Stegun, page 446 section 10.4.4 on Airy functions. // The number is Ai(0) = 3^{-2/3}/\Gamma(2/3). __Ai = _Tp(0.35502805388781723926L); __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); // Reference: // Abramowitz & Stegun, page 446 section 10.4.5 on Airy functions. // The number is Ai'(0) = -3^{-1/3}/\Gamma(1/3). __Aip = -_Tp(0.25881940379280679840L); __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); } return; } } // namespace __detail #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC c++/8/tr1/unordered_set000064400000003046152640040210010553 0ustar00// TR1 unordered_set -*- C++ -*- // Copyright (C) 2005-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/unordered_set * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_UNORDERED_SET #define _GLIBCXX_TR1_UNORDERED_SET 1 #pragma GCC system_header #include #include #include #include // equal_to, _Identity, _Select1st #include #include #include #include #include #endif // _GLIBCXX_TR1_UNORDERED_SET c++/8/tr1/cctype000064400000002604152640040210007177 0ustar00// TR1 cctype -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cctype * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CCTYPE #define _GLIBCXX_TR1_CCTYPE 1 #include #include #ifdef _GLIBCXX_USE_C99_CTYPE_TR1 #undef isblank namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { using ::isblank; } } #endif #endif // _GLIBCXX_TR1_CCTYPE c++/8/tr1/ell_integral.tcc000064400000066114152640040210011127 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/ell_integral.tcc * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on: // (1) B. C. Carlson Numer. Math. 33, 1 (1979) // (2) B. C. Carlson, Special Functions of Applied Mathematics (1977) // (3) The Gnu Scientific Library, http://www.gnu.org/software/gsl // (4) Numerical Recipes in C, 2nd ed, by W. H. Press, S. A. Teukolsky, // W. T. Vetterling, B. P. Flannery, Cambridge University Press // (1992), pp. 261-269 #ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC #define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { #else # error do not include this header directly, use or #endif // [5.2] Special functions // Implementation-space details. namespace __detail { /** * @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$ * of the first kind. * * The Carlson elliptic function of the first kind is defined by: * @f[ * R_F(x,y,z) = \frac{1}{2} \int_0^\infty * \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}} * @f] * * @param __x The first of three symmetric arguments. * @param __y The second of three symmetric arguments. * @param __z The third of three symmetric arguments. * @return The Carlson elliptic function of the first kind. */ template _Tp __ellint_rf(_Tp __x, _Tp __y, _Tp __z) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(5) * __min; const _Tp __uplim = __max / _Tp(5); if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) std::__throw_domain_error(__N("Argument less than zero " "in __ellint_rf.")); else if (__x + __y < __lolim || __x + __z < __lolim || __y + __z < __lolim) std::__throw_domain_error(__N("Argument too small in __ellint_rf")); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(1) / _Tp(24); const _Tp __c2 = _Tp(1) / _Tp(10); const _Tp __c3 = _Tp(3) / _Tp(44); const _Tp __c4 = _Tp(1) / _Tp(14); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); _Tp __mu; _Tp __xndev, __yndev, __zndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + __zn) / _Tp(3); __xndev = 2 - (__mu + __xn) / __mu; __yndev = 2 - (__mu + __yn) / __mu; __zndev = 2 - (__mu + __zn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); if (__epsilon < __errtol) break; const _Tp __xnroot = std::sqrt(__xn); const _Tp __ynroot = std::sqrt(__yn); const _Tp __znroot = std::sqrt(__zn); const _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); } const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; const _Tp __e3 = __xndev * __yndev * __zndev; const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + __c4 * __e3; return __s / std::sqrt(__mu); } } /** * @brief Return the complete elliptic integral of the first kind * @f$ K(k) @f$ by series expansion. * * The complete elliptic integral of the first kind is defined as * @f[ * K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta} * {\sqrt{1 - k^2sin^2\theta}} * @f] * * This routine is not bad as long as |k| is somewhat smaller than 1 * but is not is good as the Carlson elliptic integral formulation. * * @param __k The argument of the complete elliptic function. * @return The complete elliptic function of the first kind. */ template _Tp __comp_ellint_1_series(_Tp __k) { const _Tp __kk = __k * __k; _Tp __term = __kk / _Tp(4); _Tp __sum = _Tp(1) + __term; const unsigned int __max_iter = 1000; for (unsigned int __i = 2; __i < __max_iter; ++__i) { __term *= (2 * __i - 1) * __kk / (2 * __i); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return __numeric_constants<_Tp>::__pi_2() * __sum; } /** * @brief Return the complete elliptic integral of the first kind * @f$ K(k) @f$ using the Carlson formulation. * * The complete elliptic integral of the first kind is defined as * @f[ * K(k) = F(k,\pi/2) = \int_0^{\pi/2}\frac{d\theta} * {\sqrt{1 - k^2 sin^2\theta}} * @f] * where @f$ F(k,\phi) @f$ is the incomplete elliptic integral of the * first kind. * * @param __k The argument of the complete elliptic function. * @return The complete elliptic function of the first kind. */ template _Tp __comp_ellint_1(_Tp __k) { if (__isnan(__k)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) >= _Tp(1)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); } /** * @brief Return the incomplete elliptic integral of the first kind * @f$ F(k,\phi) @f$ using the Carlson formulation. * * The incomplete elliptic integral of the first kind is defined as * @f[ * F(k,\phi) = \int_0^{\phi}\frac{d\theta} * {\sqrt{1 - k^2 sin^2\theta}} * @f] * * @param __k The argument of the elliptic function. * @param __phi The integral limit argument of the elliptic function. * @return The elliptic function of the first kind. */ template _Tp __ellint_1(_Tp __k, _Tp __phi) { if (__isnan(__k) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(__N("Bad argument in __ellint_1.")); else { // Reduce phi to -pi/2 < phi < +pi/2. const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __s = std::sin(__phi_red); const _Tp __c = std::cos(__phi_red); const _Tp __F = __s * __ellint_rf(__c * __c, _Tp(1) - __k * __k * __s * __s, _Tp(1)); if (__n == 0) return __F; else return __F + _Tp(2) * __n * __comp_ellint_1(__k); } } /** * @brief Return the complete elliptic integral of the second kind * @f$ E(k) @f$ by series expansion. * * The complete elliptic integral of the second kind is defined as * @f[ * E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta} * @f] * * This routine is not bad as long as |k| is somewhat smaller than 1 * but is not is good as the Carlson elliptic integral formulation. * * @param __k The argument of the complete elliptic function. * @return The complete elliptic function of the second kind. */ template _Tp __comp_ellint_2_series(_Tp __k) { const _Tp __kk = __k * __k; _Tp __term = __kk; _Tp __sum = __term; const unsigned int __max_iter = 1000; for (unsigned int __i = 2; __i < __max_iter; ++__i) { const _Tp __i2m = 2 * __i - 1; const _Tp __i2 = 2 * __i; __term *= __i2m * __i2m * __kk / (__i2 * __i2); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term / __i2m; } return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); } /** * @brief Return the Carlson elliptic function of the second kind * @f$ R_D(x,y,z) = R_J(x,y,z,z) @f$ where * @f$ R_J(x,y,z,p) @f$ is the Carlson elliptic function * of the third kind. * * The Carlson elliptic function of the second kind is defined by: * @f[ * R_D(x,y,z) = \frac{3}{2} \int_0^\infty * \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{3/2}} * @f] * * Based on Carlson's algorithms: * - B. C. Carlson Numer. Math. 33, 1 (1979) * - B. C. Carlson, Special Functions of Applied Mathematics (1977) * - Numerical Recipes in C, 2nd ed, pp. 261-269, * by Press, Teukolsky, Vetterling, Flannery (1992) * * @param __x The first of two symmetric arguments. * @param __y The second of two symmetric arguments. * @param __z The third argument. * @return The Carlson elliptic function of the second kind. */ template _Tp __ellint_rd(_Tp __x, _Tp __y, _Tp __z) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3)); if (__x < _Tp(0) || __y < _Tp(0)) std::__throw_domain_error(__N("Argument less than zero " "in __ellint_rd.")); else if (__x + __y < __lolim || __z < __lolim) std::__throw_domain_error(__N("Argument too small " "in __ellint_rd.")); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(3) / _Tp(14); const _Tp __c2 = _Tp(1) / _Tp(6); const _Tp __c3 = _Tp(9) / _Tp(22); const _Tp __c4 = _Tp(3) / _Tp(26); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; _Tp __sigma = _Tp(0); _Tp __power4 = _Tp(1); _Tp __mu; _Tp __xndev, __yndev, __zndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); __xndev = (__mu - __xn) / __mu; __yndev = (__mu - __yn) / __mu; __zndev = (__mu - __zn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); if (__epsilon < __errtol) break; _Tp __xnroot = std::sqrt(__xn); _Tp __ynroot = std::sqrt(__yn); _Tp __znroot = std::sqrt(__zn); _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; __sigma += __power4 / (__znroot * (__zn + __lambda)); __power4 *= __c0; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); } // Note: __ea is an SPU badname. _Tp __eaa = __xndev * __yndev; _Tp __eb = __zndev * __zndev; _Tp __ec = __eaa - __eb; _Tp __ed = __eaa - _Tp(6) * __eb; _Tp __ef = __ed + __ec + __ec; _Tp __s1 = __ed * (-__c1 + __c3 * __ed / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef / _Tp(2)); _Tp __s2 = __zndev * (__c2 * __ef + __zndev * (-__c3 * __ec - __zndev * __c4 - __eaa)); return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) / (__mu * std::sqrt(__mu)); } } /** * @brief Return the complete elliptic integral of the second kind * @f$ E(k) @f$ using the Carlson formulation. * * The complete elliptic integral of the second kind is defined as * @f[ * E(k,\pi/2) = \int_0^{\pi/2}\sqrt{1 - k^2 sin^2\theta} * @f] * * @param __k The argument of the complete elliptic function. * @return The complete elliptic function of the second kind. */ template _Tp __comp_ellint_2(_Tp __k) { if (__isnan(__k)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) == 1) return _Tp(1); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(__N("Bad argument in __comp_ellint_2.")); else { const _Tp __kk = __k * __k; return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); } } /** * @brief Return the incomplete elliptic integral of the second kind * @f$ E(k,\phi) @f$ using the Carlson formulation. * * The incomplete elliptic integral of the second kind is defined as * @f[ * E(k,\phi) = \int_0^{\phi} \sqrt{1 - k^2 sin^2\theta} * @f] * * @param __k The argument of the elliptic function. * @param __phi The integral limit argument of the elliptic function. * @return The elliptic function of the second kind. */ template _Tp __ellint_2(_Tp __k, _Tp __phi) { if (__isnan(__k) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(__N("Bad argument in __ellint_2.")); else { // Reduce phi to -pi/2 < phi < +pi/2. const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __kk = __k * __k; const _Tp __s = std::sin(__phi_red); const _Tp __ss = __s * __s; const _Tp __sss = __ss * __s; const _Tp __c = std::cos(__phi_red); const _Tp __cc = __c * __c; const _Tp __E = __s * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) - __kk * __sss * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) / _Tp(3); if (__n == 0) return __E; else return __E + _Tp(2) * __n * __comp_ellint_2(__k); } } /** * @brief Return the Carlson elliptic function * @f$ R_C(x,y) = R_F(x,y,y) @f$ where @f$ R_F(x,y,z) @f$ * is the Carlson elliptic function of the first kind. * * The Carlson elliptic function is defined by: * @f[ * R_C(x,y) = \frac{1}{2} \int_0^\infty * \frac{dt}{(t + x)^{1/2}(t + y)} * @f] * * Based on Carlson's algorithms: * - B. C. Carlson Numer. Math. 33, 1 (1979) * - B. C. Carlson, Special Functions of Applied Mathematics (1977) * - Numerical Recipes in C, 2nd ed, pp. 261-269, * by Press, Teukolsky, Vetterling, Flannery (1992) * * @param __x The first argument. * @param __y The second argument. * @return The Carlson elliptic function. */ template _Tp __ellint_rc(_Tp __x, _Tp __y) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(5) * __min; const _Tp __uplim = __max / _Tp(5); if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) std::__throw_domain_error(__N("Argument less than zero " "in __ellint_rc.")); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(1) / _Tp(7); const _Tp __c2 = _Tp(9) / _Tp(22); const _Tp __c3 = _Tp(3) / _Tp(10); const _Tp __c4 = _Tp(3) / _Tp(8); _Tp __xn = __x; _Tp __yn = __y; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); _Tp __mu; _Tp __sn; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + _Tp(2) * __yn) / _Tp(3); __sn = (__yn + __mu) / __mu - _Tp(2); if (std::abs(__sn) < __errtol) break; const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + __yn; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); } _Tp __s = __sn * __sn * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); return (_Tp(1) + __s) / std::sqrt(__mu); } } /** * @brief Return the Carlson elliptic function @f$ R_J(x,y,z,p) @f$ * of the third kind. * * The Carlson elliptic function of the third kind is defined by: * @f[ * R_J(x,y,z,p) = \frac{3}{2} \int_0^\infty * \frac{dt}{(t + x)^{1/2}(t + y)^{1/2}(t + z)^{1/2}(t + p)} * @f] * * Based on Carlson's algorithms: * - B. C. Carlson Numer. Math. 33, 1 (1979) * - B. C. Carlson, Special Functions of Applied Mathematics (1977) * - Numerical Recipes in C, 2nd ed, pp. 261-269, * by Press, Teukolsky, Vetterling, Flannery (1992) * * @param __x The first of three symmetric arguments. * @param __y The second of three symmetric arguments. * @param __z The third of three symmetric arguments. * @param __p The fourth argument. * @return The Carlson elliptic function of the fourth kind. */ template _Tp __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); const _Tp __uplim = _Tp(0.3L) * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3)); if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) std::__throw_domain_error(__N("Argument less than zero " "in __ellint_rj.")); else if (__x + __y < __lolim || __x + __z < __lolim || __y + __z < __lolim || __p < __lolim) std::__throw_domain_error(__N("Argument too small " "in __ellint_rj")); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(3) / _Tp(14); const _Tp __c2 = _Tp(1) / _Tp(3); const _Tp __c3 = _Tp(3) / _Tp(22); const _Tp __c4 = _Tp(3) / _Tp(26); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; _Tp __pn = __p; _Tp __sigma = _Tp(0); _Tp __power4 = _Tp(1); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); _Tp __lambda, __mu; _Tp __xndev, __yndev, __zndev, __pndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); __xndev = (__mu - __xn) / __mu; __yndev = (__mu - __yn) / __mu; __zndev = (__mu - __zn) / __mu; __pndev = (__mu - __pn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); __epsilon = std::max(__epsilon, std::abs(__pndev)); if (__epsilon < __errtol) break; const _Tp __xnroot = std::sqrt(__xn); const _Tp __ynroot = std::sqrt(__yn); const _Tp __znroot = std::sqrt(__zn); const _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + __xnroot * __ynroot * __znroot; const _Tp __alpha2 = __alpha1 * __alpha1; const _Tp __beta = __pn * (__pn + __lambda) * (__pn + __lambda); __sigma += __power4 * __ellint_rc(__alpha2, __beta); __power4 *= __c0; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); __pn = __c0 * (__pn + __lambda); } // Note: __ea is an SPU badname. _Tp __eaa = __xndev * (__yndev + __zndev) + __yndev * __zndev; _Tp __eb = __xndev * __yndev * __zndev; _Tp __ec = __pndev * __pndev; _Tp __e2 = __eaa - _Tp(3) * __ec; _Tp __e3 = __eb + _Tp(2) * __pndev * (__eaa - __ec); _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) - _Tp(3) * __c4 * __e3 / _Tp(2)); _Tp __s2 = __eb * (__c2 / _Tp(2) + __pndev * (-__c3 - __c3 + __pndev * __c4)); _Tp __s3 = __pndev * __eaa * (__c2 - __pndev * __c3) - __c2 * __pndev * __ec; return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) / (__mu * std::sqrt(__mu)); } } /** * @brief Return the complete elliptic integral of the third kind * @f$ \Pi(k,\nu) = \Pi(k,\nu,\pi/2) @f$ using the * Carlson formulation. * * The complete elliptic integral of the third kind is defined as * @f[ * \Pi(k,\nu) = \int_0^{\pi/2} * \frac{d\theta} * {(1 - \nu \sin^2\theta)\sqrt{1 - k^2 \sin^2\theta}} * @f] * * @param __k The argument of the elliptic function. * @param __nu The second argument of the elliptic function. * @return The complete elliptic function of the third kind. */ template _Tp __comp_ellint_3(_Tp __k, _Tp __nu) { if (__isnan(__k) || __isnan(__nu)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__nu == _Tp(1)) return std::numeric_limits<_Tp>::infinity(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(__N("Bad argument in __comp_ellint_3.")); else { const _Tp __kk = __k * __k; return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + __nu * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) / _Tp(3); } } /** * @brief Return the incomplete elliptic integral of the third kind * @f$ \Pi(k,\nu,\phi) @f$ using the Carlson formulation. * * The incomplete elliptic integral of the third kind is defined as * @f[ * \Pi(k,\nu,\phi) = \int_0^{\phi} * \frac{d\theta} * {(1 - \nu \sin^2\theta) * \sqrt{1 - k^2 \sin^2\theta}} * @f] * * @param __k The argument of the elliptic function. * @param __nu The second argument of the elliptic function. * @param __phi The integral limit argument of the elliptic function. * @return The elliptic function of the third kind. */ template _Tp __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) { if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(__N("Bad argument in __ellint_3.")); else { // Reduce phi to -pi/2 < phi < +pi/2. const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __kk = __k * __k; const _Tp __s = std::sin(__phi_red); const _Tp __ss = __s * __s; const _Tp __sss = __ss * __s; const _Tp __c = std::cos(__phi_red); const _Tp __cc = __c * __c; const _Tp __Pi = __s * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + __nu * __sss * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), _Tp(1) - __nu * __ss) / _Tp(3); if (__n == 0) return __Pi; else return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); } } } // namespace __detail #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC c++/8/tr1/float.h000064400000002271152640040210007243 0ustar00// TR1 float.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/float.h * This is a TR1 C++ Library header. */ #ifndef _TR1_FLOAT_H #define _TR1_FLOAT_H 1 #include #endif c++/8/tr1/cwctype000064400000002663152640040210007373 0ustar00// TR1 cwctype -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/cwctype * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CWCTYPE #define _GLIBCXX_TR1_CWCTYPE 1 #pragma GCC system_header #include #ifdef _GLIBCXX_USE_WCHAR_T namespace std _GLIBCXX_VISIBILITY(default) { namespace tr1 { #if _GLIBCXX_HAVE_ISWBLANK using std::iswblank; #endif } } #endif // _GLIBCXX_USE_WCHAR_T #endif // _GLIBCXX_TR1_CWCTYPE c++/8/tr1/ctgmath000064400000002340152640040210007334 0ustar00// TR1 ctgmath -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/ctgmath * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_CTGMATH #define _GLIBCXX_TR1_CTGMATH 1 #include #endif // _GLIBCXX_TR1_CTGMATH c++/8/tr1/wctype.h000064400000002347152640040210007455 0ustar00// TR1 wctype.h -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/wctype.h * This is a TR1 C++ Library header. */ #ifndef _GLIBCXX_TR1_WCTYPE_H #define _GLIBCXX_TR1_WCTYPE_H 1 #include #endif // _GLIBCXX_TR1_WCTYPE_H c++/8/tr1/random.h000064400000216643152640040210007430 0ustar00// random number generation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** * @file tr1/random.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/random} */ #ifndef _GLIBCXX_TR1_RANDOM_H #define _GLIBCXX_TR1_RANDOM_H 1 #pragma GCC system_header namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace tr1 { // [5.1] Random number generation /** * @addtogroup tr1_random Random Number Generation * A facility for generating random numbers on selected distributions. * @{ */ /* * Implementation-space details. */ namespace __detail { template::digits> struct _Shift { static const _UIntType __value = 0; }; template struct _Shift<_UIntType, __w, true> { static const _UIntType __value = _UIntType(1) << __w; }; template struct _Mod; // Dispatch based on modulus value to prevent divide-by-zero compile-time // errors when m == 0. template inline _Tp __mod(_Tp __x) { return _Mod<_Tp, __a, __c, __m, __m == 0>::__calc(__x); } typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4), unsigned, unsigned long>::__type _UInt32Type; /* * An adaptor class for converting the output of any Generator into * the input for a specific Distribution. */ template struct _Adaptor { typedef typename remove_reference<_Engine>::type _BEngine; typedef typename _BEngine::result_type _Engine_result_type; typedef typename _Distribution::input_type result_type; public: _Adaptor(const _Engine& __g) : _M_g(__g) { } result_type min() const { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = _M_g.min(); else __return_value = result_type(0); return __return_value; } result_type max() const { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = _M_g.max(); else if (!is_integral::value) __return_value = result_type(1); else __return_value = std::numeric_limits::max() - 1; return __return_value; } /* * Converts a value generated by the adapted random number generator * into a value in the input domain for the dependent random number * distribution. * * Because the type traits are compile time constants only the * appropriate clause of the if statements will actually be emitted * by the compiler. */ result_type operator()() { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = _M_g(); else if (!is_integral<_Engine_result_type>::value && !is_integral::value) __return_value = result_type(_M_g() - _M_g.min()) / result_type(_M_g.max() - _M_g.min()); else if (is_integral<_Engine_result_type>::value && !is_integral::value) __return_value = result_type(_M_g() - _M_g.min()) / result_type(_M_g.max() - _M_g.min() + result_type(1)); else __return_value = (((_M_g() - _M_g.min()) / (_M_g.max() - _M_g.min())) * std::numeric_limits::max()); return __return_value; } private: _Engine _M_g; }; // Specialization for _Engine*. template struct _Adaptor<_Engine*, _Distribution> { typedef typename _Engine::result_type _Engine_result_type; typedef typename _Distribution::input_type result_type; public: _Adaptor(_Engine* __g) : _M_g(__g) { } result_type min() const { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = _M_g->min(); else __return_value = result_type(0); return __return_value; } result_type max() const { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = _M_g->max(); else if (!is_integral::value) __return_value = result_type(1); else __return_value = std::numeric_limits::max() - 1; return __return_value; } result_type operator()() { result_type __return_value; if (is_integral<_Engine_result_type>::value && is_integral::value) __return_value = (*_M_g)(); else if (!is_integral<_Engine_result_type>::value && !is_integral::value) __return_value = result_type((*_M_g)() - _M_g->min()) / result_type(_M_g->max() - _M_g->min()); else if (is_integral<_Engine_result_type>::value && !is_integral::value) __return_value = result_type((*_M_g)() - _M_g->min()) / result_type(_M_g->max() - _M_g->min() + result_type(1)); else __return_value = ((((*_M_g)() - _M_g->min()) / (_M_g->max() - _M_g->min())) * std::numeric_limits::max()); return __return_value; } private: _Engine* _M_g; }; } // namespace __detail /** * Produces random numbers on a given distribution function using a * non-uniform random number generation engine. * * @todo the engine_value_type needs to be studied more carefully. */ template class variate_generator { // Concept requirements. __glibcxx_class_requires(_Engine, _CopyConstructibleConcept) // __glibcxx_class_requires(_Engine, _EngineConcept) // __glibcxx_class_requires(_Dist, _EngineConcept) public: typedef _Engine engine_type; typedef __detail::_Adaptor<_Engine, _Dist> engine_value_type; typedef _Dist distribution_type; typedef typename _Dist::result_type result_type; // tr1:5.1.1 table 5.1 requirement typedef typename __gnu_cxx::__enable_if< is_arithmetic::value, result_type>::__type _IsValidType; /** * Constructs a variate generator with the uniform random number * generator @p __eng for the random distribution @p __dist. * * @throws Any exceptions which may thrown by the copy constructors of * the @p _Engine or @p _Dist objects. */ variate_generator(engine_type __eng, distribution_type __dist) : _M_engine(__eng), _M_dist(__dist) { } /** * Gets the next generated value on the distribution. */ result_type operator()() { return _M_dist(_M_engine); } /** * WTF? */ template result_type operator()(_Tp __value) { return _M_dist(_M_engine, __value); } /** * Gets a reference to the underlying uniform random number generator * object. */ engine_value_type& engine() { return _M_engine; } /** * Gets a const reference to the underlying uniform random number * generator object. */ const engine_value_type& engine() const { return _M_engine; } /** * Gets a reference to the underlying random distribution. */ distribution_type& distribution() { return _M_dist; } /** * Gets a const reference to the underlying random distribution. */ const distribution_type& distribution() const { return _M_dist; } /** * Gets the closed lower bound of the distribution interval. */ result_type min() const { return this->distribution().min(); } /** * Gets the closed upper bound of the distribution interval. */ result_type max() const { return this->distribution().max(); } private: engine_value_type _M_engine; distribution_type _M_dist; }; /** * @addtogroup tr1_random_generators Random Number Generators * @ingroup tr1_random * * These classes define objects which provide random or pseudorandom * numbers, either from a discrete or a continuous interval. The * random number generator supplied as a part of this library are * all uniform random number generators which provide a sequence of * random number uniformly distributed over their range. * * A number generator is a function object with an operator() that * takes zero arguments and returns a number. * * A compliant random number generator must satisfy the following * requirements. * *
Random Number Generator Requirements
To be documented.
* * @{ */ /** * @brief A model of a linear congruential random number generator. * * A random number generator that produces pseudorandom numbers using the * linear function @f$x_{i+1}\leftarrow(ax_{i} + c) \bmod m @f$. * * The template parameter @p _UIntType must be an unsigned integral type * large enough to store values up to (__m-1). If the template parameter * @p __m is 0, the modulus @p __m used is * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template * parameters @p __a and @p __c must be less than @p __m. * * The size of the state is @f$ 1 @f$. */ template class linear_congruential { __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept) // __glibcpp_class_requires(__a < __m && __c < __m) public: /** The type of the generated random value. */ typedef _UIntType result_type; /** The multiplier. */ static const _UIntType multiplier = __a; /** An increment. */ static const _UIntType increment = __c; /** The modulus. */ static const _UIntType modulus = __m; /** * Constructs a %linear_congruential random number generator engine with * seed @p __s. The default seed value is 1. * * @param __s The initial seed value. */ explicit linear_congruential(unsigned long __x0 = 1) { this->seed(__x0); } /** * Constructs a %linear_congruential random number generator engine * seeded from the generator function @p __g. * * @param __g The seed generator function. */ template linear_congruential(_Gen& __g) { this->seed(__g); } /** * Reseeds the %linear_congruential random number generator engine * sequence to the seed @g __s. * * @param __s The new seed. */ void seed(unsigned long __s = 1); /** * Reseeds the %linear_congruential random number generator engine * sequence using values from the generator function @p __g. * * @param __g the seed generator function. */ template void seed(_Gen& __g) { seed(__g, typename is_fundamental<_Gen>::type()); } /** * Gets the smallest possible value in the output range. * * The minimum depends on the @p __c parameter: if it is zero, the * minimum generated must be > 0, otherwise 0 is allowed. */ result_type min() const { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; } /** * Gets the largest possible value in the output range. */ result_type max() const { return __m - 1; } /** * Gets the next random number in the sequence. */ result_type operator()(); /** * Compares two linear congruential random number generator * objects of the same type for equality. * * @param __lhs A linear congruential random number generator object. * @param __rhs Another linear congruential random number generator obj. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const linear_congruential& __lhs, const linear_congruential& __rhs) { return __lhs._M_x == __rhs._M_x; } /** * Compares two linear congruential random number generator * objects of the same type for inequality. * * @param __lhs A linear congruential random number generator object. * @param __rhs Another linear congruential random number generator obj. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const linear_congruential& __lhs, const linear_congruential& __rhs) { return !(__lhs == __rhs); } /** * Writes the textual representation of the state x(i) of x to @p __os. * * @param __os The output stream. * @param __lcr A % linear_congruential random number generator. * @returns __os. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr); /** * Sets the state of the engine by reading its textual * representation from @p __is. * * The textual representation must have been previously written using an * output stream whose imbued locale and whose type's template * specialization arguments _CharT and _Traits were the same as those of * @p __is. * * @param __is The input stream. * @param __lcr A % linear_congruential random number generator. * @returns __is. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, linear_congruential<_UIntType1, __a1, __c1, __m1>& __lcr); private: template void seed(_Gen& __g, true_type) { return seed(static_cast(__g)); } template void seed(_Gen& __g, false_type); _UIntType _M_x; }; /** * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller. */ typedef linear_congruential minstd_rand0; /** * An alternative LCR (Lehmer Generator function) . */ typedef linear_congruential minstd_rand; /** * A generalized feedback shift register discrete random number generator. * * This algorithm avoids multiplication and division and is designed to be * friendly to a pipelined architecture. If the parameters are chosen * correctly, this generator will produce numbers with a very long period and * fairly good apparent entropy, although still not cryptographically strong. * * The best way to use this generator is with the predefined mt19937 class. * * This algorithm was originally invented by Makoto Matsumoto and * Takuji Nishimura. * * @var word_size The number of bits in each element of the state vector. * @var state_size The degree of recursion. * @var shift_size The period parameter. * @var mask_bits The separation point bit index. * @var parameter_a The last row of the twist matrix. * @var output_u The first right-shift tempering matrix parameter. * @var output_s The first left-shift tempering matrix parameter. * @var output_b The first left-shift tempering matrix mask. * @var output_t The second left-shift tempering matrix parameter. * @var output_c The second left-shift tempering matrix mask. * @var output_l The second right-shift tempering matrix parameter. */ template class mersenne_twister { __glibcxx_class_requires(_UIntType, _UnsignedIntegerConcept) public: // types typedef _UIntType result_type; // parameter values static const int word_size = __w; static const int state_size = __n; static const int shift_size = __m; static const int mask_bits = __r; static const _UIntType parameter_a = __a; static const int output_u = __u; static const int output_s = __s; static const _UIntType output_b = __b; static const int output_t = __t; static const _UIntType output_c = __c; static const int output_l = __l; // constructors and member function mersenne_twister() { seed(); } explicit mersenne_twister(unsigned long __value) { seed(__value); } template mersenne_twister(_Gen& __g) { seed(__g); } void seed() { seed(5489UL); } void seed(unsigned long __value); template void seed(_Gen& __g) { seed(__g, typename is_fundamental<_Gen>::type()); } result_type min() const { return 0; } result_type max() const { return __detail::_Shift<_UIntType, __w>::__value - 1; } result_type operator()(); /** * Compares two % mersenne_twister random number generator objects of * the same type for equality. * * @param __lhs A % mersenne_twister random number generator object. * @param __rhs Another % mersenne_twister random number generator * object. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const mersenne_twister& __lhs, const mersenne_twister& __rhs) { return std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x); } /** * Compares two % mersenne_twister random number generator objects of * the same type for inequality. * * @param __lhs A % mersenne_twister random number generator object. * @param __rhs Another % mersenne_twister random number generator * object. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const mersenne_twister& __lhs, const mersenne_twister& __rhs) { return !(__lhs == __rhs); } /** * Inserts the current state of a % mersenne_twister random number * generator engine @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A % mersenne_twister random number generator engine. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x); /** * Extracts the current state of a % mersenne_twister random number * generator engine @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A % mersenne_twister random number generator engine. * * @returns The input stream with the state of @p __x extracted or in * an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, mersenne_twister<_UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __s1, __b1, __t1, __c1, __l1>& __x); private: template void seed(_Gen& __g, true_type) { return seed(static_cast(__g)); } template void seed(_Gen& __g, false_type); _UIntType _M_x[state_size]; int _M_p; }; /** * The classic Mersenne Twister. * * Reference: * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30. */ typedef mersenne_twister< unsigned long, 32, 624, 397, 31, 0x9908b0dful, 11, 7, 0x9d2c5680ul, 15, 0xefc60000ul, 18 > mt19937; /** * @brief The Marsaglia-Zaman generator. * * This is a model of a Generalized Fibonacci discrete random number * generator, sometimes referred to as the SWC generator. * * A discrete random number generator that produces pseudorandom * numbers using @f$x_{i}\leftarrow(x_{i - s} - x_{i - r} - * carry_{i-1}) \bmod m @f$. * * The size of the state is @f$ r @f$ * and the maximum period of the generator is @f$ m^r - m^s -1 @f$. * * N1688[4.13] says the template parameter _IntType shall denote * an integral type large enough to store values up to m. * * @var _M_x The state of the generator. This is a ring buffer. * @var _M_carry The carry. * @var _M_p Current index of x(i - r). */ template class subtract_with_carry { __glibcxx_class_requires(_IntType, _IntegerConcept) public: /** The type of the generated random value. */ typedef _IntType result_type; // parameter values static const _IntType modulus = __m; static const int long_lag = __r; static const int short_lag = __s; /** * Constructs a default-initialized % subtract_with_carry random number * generator. */ subtract_with_carry() { this->seed(); } /** * Constructs an explicitly seeded % subtract_with_carry random number * generator. */ explicit subtract_with_carry(unsigned long __value) { this->seed(__value); } /** * Constructs a %subtract_with_carry random number generator engine * seeded from the generator function @p __g. * * @param __g The seed generator function. */ template subtract_with_carry(_Gen& __g) { this->seed(__g); } /** * Seeds the initial state @f$ x_0 @f$ of the random number generator. * * N1688[4.19] modifies this as follows. If @p __value == 0, * sets value to 19780503. In any case, with a linear * congruential generator lcg(i) having parameters @f$ m_{lcg} = * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$ * set carry to 1, otherwise sets carry to 0. */ void seed(unsigned long __value = 19780503); /** * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry * random number generator. */ template void seed(_Gen& __g) { seed(__g, typename is_fundamental<_Gen>::type()); } /** * Gets the inclusive minimum value of the range of random integers * returned by this generator. */ result_type min() const { return 0; } /** * Gets the inclusive maximum value of the range of random integers * returned by this generator. */ result_type max() const { return this->modulus - 1; } /** * Gets the next random number in the sequence. */ result_type operator()(); /** * Compares two % subtract_with_carry random number generator objects of * the same type for equality. * * @param __lhs A % subtract_with_carry random number generator object. * @param __rhs Another % subtract_with_carry random number generator * object. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const subtract_with_carry& __lhs, const subtract_with_carry& __rhs) { return std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x); } /** * Compares two % subtract_with_carry random number generator objects of * the same type for inequality. * * @param __lhs A % subtract_with_carry random number generator object. * @param __rhs Another % subtract_with_carry random number generator * object. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const subtract_with_carry& __lhs, const subtract_with_carry& __rhs) { return !(__lhs == __rhs); } /** * Inserts the current state of a % subtract_with_carry random number * generator engine @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A % subtract_with_carry random number generator engine. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x); /** * Extracts the current state of a % subtract_with_carry random number * generator engine @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A % subtract_with_carry random number generator engine. * * @returns The input stream with the state of @p __x extracted or in * an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, subtract_with_carry<_IntType1, __m1, __s1, __r1>& __x); private: template void seed(_Gen& __g, true_type) { return seed(static_cast(__g)); } template void seed(_Gen& __g, false_type); typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType; _UIntType _M_x[long_lag]; _UIntType _M_carry; int _M_p; }; /** * @brief The Marsaglia-Zaman generator (floats version). * * @var _M_x The state of the generator. This is a ring buffer. * @var _M_carry The carry. * @var _M_p Current index of x(i - r). * @var _M_npows Precomputed negative powers of 2. */ template class subtract_with_carry_01 { public: /** The type of the generated random value. */ typedef _RealType result_type; // parameter values static const int word_size = __w; static const int long_lag = __r; static const int short_lag = __s; /** * Constructs a default-initialized % subtract_with_carry_01 random * number generator. */ subtract_with_carry_01() { this->seed(); _M_initialize_npows(); } /** * Constructs an explicitly seeded % subtract_with_carry_01 random number * generator. */ explicit subtract_with_carry_01(unsigned long __value) { this->seed(__value); _M_initialize_npows(); } /** * Constructs a % subtract_with_carry_01 random number generator engine * seeded from the generator function @p __g. * * @param __g The seed generator function. */ template subtract_with_carry_01(_Gen& __g) { this->seed(__g); _M_initialize_npows(); } /** * Seeds the initial state @f$ x_0 @f$ of the random number generator. */ void seed(unsigned long __value = 19780503); /** * Seeds the initial state @f$ x_0 @f$ of the % subtract_with_carry_01 * random number generator. */ template void seed(_Gen& __g) { seed(__g, typename is_fundamental<_Gen>::type()); } /** * Gets the minimum value of the range of random floats * returned by this generator. */ result_type min() const { return 0.0; } /** * Gets the maximum value of the range of random floats * returned by this generator. */ result_type max() const { return 1.0; } /** * Gets the next random number in the sequence. */ result_type operator()(); /** * Compares two % subtract_with_carry_01 random number generator objects * of the same type for equality. * * @param __lhs A % subtract_with_carry_01 random number * generator object. * @param __rhs Another % subtract_with_carry_01 random number generator * object. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const subtract_with_carry_01& __lhs, const subtract_with_carry_01& __rhs) { for (int __i = 0; __i < long_lag; ++__i) if (!std::equal(__lhs._M_x[__i], __lhs._M_x[__i] + __n, __rhs._M_x[__i])) return false; return true; } /** * Compares two % subtract_with_carry_01 random number generator objects * of the same type for inequality. * * @param __lhs A % subtract_with_carry_01 random number * generator object. * * @param __rhs Another % subtract_with_carry_01 random number generator * object. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const subtract_with_carry_01& __lhs, const subtract_with_carry_01& __rhs) { return !(__lhs == __rhs); } /** * Inserts the current state of a % subtract_with_carry_01 random number * generator engine @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A % subtract_with_carry_01 random number generator engine. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x); /** * Extracts the current state of a % subtract_with_carry_01 random number * generator engine @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A % subtract_with_carry_01 random number generator engine. * * @returns The input stream with the state of @p __x extracted or in * an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, subtract_with_carry_01<_RealType1, __w1, __s1, __r1>& __x); private: template void seed(_Gen& __g, true_type) { return seed(static_cast(__g)); } template void seed(_Gen& __g, false_type); void _M_initialize_npows(); static const int __n = (__w + 31) / 32; typedef __detail::_UInt32Type _UInt32Type; _UInt32Type _M_x[long_lag][__n]; _RealType _M_npows[__n]; _UInt32Type _M_carry; int _M_p; }; typedef subtract_with_carry_01 ranlux_base_01; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 508. Bad parameters for ranlux64_base_01. typedef subtract_with_carry_01 ranlux64_base_01; /** * Produces random numbers from some base engine by discarding blocks of * data. * * 0 <= @p __r <= @p __p */ template class discard_block { // __glibcxx_class_requires(typename base_type::result_type, // ArithmeticTypeConcept) public: /** The type of the underlying generator engine. */ typedef _UniformRandomNumberGenerator base_type; /** The type of the generated random value. */ typedef typename base_type::result_type result_type; // parameter values static const int block_size = __p; static const int used_block = __r; /** * Constructs a default %discard_block engine. * * The underlying engine is default constructed as well. */ discard_block() : _M_n(0) { } /** * Copy constructs a %discard_block engine. * * Copies an existing base class random number generator. * @param rng An existing (base class) engine object. */ explicit discard_block(const base_type& __rng) : _M_b(__rng), _M_n(0) { } /** * Seed constructs a %discard_block engine. * * Constructs the underlying generator engine seeded with @p __s. * @param __s A seed value for the base class engine. */ explicit discard_block(unsigned long __s) : _M_b(__s), _M_n(0) { } /** * Generator construct a %discard_block engine. * * @param __g A seed generator function. */ template discard_block(_Gen& __g) : _M_b(__g), _M_n(0) { } /** * Reseeds the %discard_block object with the default seed for the * underlying base class generator engine. */ void seed() { _M_b.seed(); _M_n = 0; } /** * Reseeds the %discard_block object with the given seed generator * function. * @param __g A seed generator function. */ template void seed(_Gen& __g) { _M_b.seed(__g); _M_n = 0; } /** * Gets a const reference to the underlying generator engine object. */ const base_type& base() const { return _M_b; } /** * Gets the minimum value in the generated random number range. */ result_type min() const { return _M_b.min(); } /** * Gets the maximum value in the generated random number range. */ result_type max() const { return _M_b.max(); } /** * Gets the next value in the generated random number sequence. */ result_type operator()(); /** * Compares two %discard_block random number generator objects of * the same type for equality. * * @param __lhs A %discard_block random number generator object. * @param __rhs Another %discard_block random number generator * object. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const discard_block& __lhs, const discard_block& __rhs) { return (__lhs._M_b == __rhs._M_b) && (__lhs._M_n == __rhs._M_n); } /** * Compares two %discard_block random number generator objects of * the same type for inequality. * * @param __lhs A %discard_block random number generator object. * @param __rhs Another %discard_block random number generator * object. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const discard_block& __lhs, const discard_block& __rhs) { return !(__lhs == __rhs); } /** * Inserts the current state of a %discard_block random number * generator engine @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %discard_block random number generator engine. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const discard_block<_UniformRandomNumberGenerator1, __p1, __r1>& __x); /** * Extracts the current state of a % subtract_with_carry random number * generator engine @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %discard_block random number generator engine. * * @returns The input stream with the state of @p __x extracted or in * an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, discard_block<_UniformRandomNumberGenerator1, __p1, __r1>& __x); private: base_type _M_b; int _M_n; }; /** * James's luxury-level-3 integer adaptation of Luescher's generator. */ typedef discard_block< subtract_with_carry, 223, 24 > ranlux3; /** * James's luxury-level-4 integer adaptation of Luescher's generator. */ typedef discard_block< subtract_with_carry, 389, 24 > ranlux4; typedef discard_block< subtract_with_carry_01, 223, 24 > ranlux3_01; typedef discard_block< subtract_with_carry_01, 389, 24 > ranlux4_01; /** * A random number generator adaptor class that combines two random number * generator engines into a single output sequence. */ template class xor_combine { // __glibcxx_class_requires(typename _UniformRandomNumberGenerator1:: // result_type, ArithmeticTypeConcept) // __glibcxx_class_requires(typename _UniformRandomNumberGenerator2:: // result_type, ArithmeticTypeConcept) public: /** The type of the first underlying generator engine. */ typedef _UniformRandomNumberGenerator1 base1_type; /** The type of the second underlying generator engine. */ typedef _UniformRandomNumberGenerator2 base2_type; private: typedef typename base1_type::result_type _Result_type1; typedef typename base2_type::result_type _Result_type2; public: /** The type of the generated random value. */ typedef typename __gnu_cxx::__conditional_type<(sizeof(_Result_type1) > sizeof(_Result_type2)), _Result_type1, _Result_type2>::__type result_type; // parameter values static const int shift1 = __s1; static const int shift2 = __s2; // constructors and member function xor_combine() : _M_b1(), _M_b2() { _M_initialize_max(); } xor_combine(const base1_type& __rng1, const base2_type& __rng2) : _M_b1(__rng1), _M_b2(__rng2) { _M_initialize_max(); } xor_combine(unsigned long __s) : _M_b1(__s), _M_b2(__s + 1) { _M_initialize_max(); } template xor_combine(_Gen& __g) : _M_b1(__g), _M_b2(__g) { _M_initialize_max(); } void seed() { _M_b1.seed(); _M_b2.seed(); } template void seed(_Gen& __g) { _M_b1.seed(__g); _M_b2.seed(__g); } const base1_type& base1() const { return _M_b1; } const base2_type& base2() const { return _M_b2; } result_type min() const { return 0; } result_type max() const { return _M_max; } /** * Gets the next random number in the sequence. */ // NB: Not exactly the TR1 formula, per N2079 instead. result_type operator()() { return ((result_type(_M_b1() - _M_b1.min()) << shift1) ^ (result_type(_M_b2() - _M_b2.min()) << shift2)); } /** * Compares two %xor_combine random number generator objects of * the same type for equality. * * @param __lhs A %xor_combine random number generator object. * @param __rhs Another %xor_combine random number generator * object. * * @returns true if the two objects are equal, false otherwise. */ friend bool operator==(const xor_combine& __lhs, const xor_combine& __rhs) { return (__lhs.base1() == __rhs.base1()) && (__lhs.base2() == __rhs.base2()); } /** * Compares two %xor_combine random number generator objects of * the same type for inequality. * * @param __lhs A %xor_combine random number generator object. * @param __rhs Another %xor_combine random number generator * object. * * @returns true if the two objects are not equal, false otherwise. */ friend bool operator!=(const xor_combine& __lhs, const xor_combine& __rhs) { return !(__lhs == __rhs); } /** * Inserts the current state of a %xor_combine random number * generator engine @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %xor_combine random number generator engine. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const xor_combine<_UniformRandomNumberGenerator11, __s11, _UniformRandomNumberGenerator21, __s21>& __x); /** * Extracts the current state of a %xor_combine random number * generator engine @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %xor_combine random number generator engine. * * @returns The input stream with the state of @p __x extracted or in * an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, xor_combine<_UniformRandomNumberGenerator11, __s11, _UniformRandomNumberGenerator21, __s21>& __x); private: void _M_initialize_max(); result_type _M_initialize_max_aux(result_type, result_type, int); base1_type _M_b1; base2_type _M_b2; result_type _M_max; }; /** * A standard interface to a platform-specific non-deterministic * random number generator (if any are available). */ class random_device { public: // types typedef unsigned int result_type; // constructors, destructors and member functions #ifdef _GLIBCXX_USE_RANDOM_TR1 explicit random_device(const std::string& __token = "/dev/urandom") { if ((__token != "/dev/urandom" && __token != "/dev/random") || !(_M_file = std::fopen(__token.c_str(), "rb"))) std::__throw_runtime_error(__N("random_device::" "random_device(const std::string&)")); } ~random_device() { std::fclose(_M_file); } #else explicit random_device(const std::string& __token = "mt19937") : _M_mt(_M_strtoul(__token)) { } private: static unsigned long _M_strtoul(const std::string& __str) { unsigned long __ret = 5489UL; if (__str != "mt19937") { const char* __nptr = __str.c_str(); char* __endptr; __ret = std::strtoul(__nptr, &__endptr, 0); if (*__nptr == '\0' || *__endptr != '\0') std::__throw_runtime_error(__N("random_device::_M_strtoul" "(const std::string&)")); } return __ret; } public: #endif result_type min() const { return std::numeric_limits::min(); } result_type max() const { return std::numeric_limits::max(); } double entropy() const { return 0.0; } result_type operator()() { #ifdef _GLIBCXX_USE_RANDOM_TR1 result_type __ret; std::fread(reinterpret_cast(&__ret), sizeof(result_type), 1, _M_file); return __ret; #else return _M_mt(); #endif } private: random_device(const random_device&); void operator=(const random_device&); #ifdef _GLIBCXX_USE_RANDOM_TR1 FILE* _M_file; #else mt19937 _M_mt; #endif }; /* @} */ // group tr1_random_generators /** * @addtogroup tr1_random_distributions Random Number Distributions * @ingroup tr1_random * @{ */ /** * @addtogroup tr1_random_distributions_discrete Discrete Distributions * @ingroup tr1_random_distributions * @{ */ /** * @brief Uniform discrete distribution for random numbers. * A discrete random distribution on the range @f$[min, max]@f$ with equal * probability throughout the range. */ template class uniform_int { __glibcxx_class_requires(_IntType, _IntegerConcept) public: /** The type of the parameters of the distribution. */ typedef _IntType input_type; /** The type of the range of the distribution. */ typedef _IntType result_type; public: /** * Constructs a uniform distribution object. */ explicit uniform_int(_IntType __min = 0, _IntType __max = 9) : _M_min(__min), _M_max(__max) { _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max); } /** * Gets the inclusive lower bound of the distribution range. */ result_type min() const { return _M_min; } /** * Gets the inclusive upper bound of the distribution range. */ result_type max() const { return _M_max; } /** * Resets the distribution state. * * Does nothing for the uniform integer distribution. */ void reset() { } /** * Gets a uniformly distributed random number in the range * @f$(min, max)@f$. */ template result_type operator()(_UniformRandomNumberGenerator& __urng) { typedef typename _UniformRandomNumberGenerator::result_type _UResult_type; return _M_call(__urng, _M_min, _M_max, typename is_integral<_UResult_type>::type()); } /** * Gets a uniform random number in the range @f$[0, n)@f$. * * This function is aimed at use with std::random_shuffle. */ template result_type operator()(_UniformRandomNumberGenerator& __urng, result_type __n) { typedef typename _UniformRandomNumberGenerator::result_type _UResult_type; return _M_call(__urng, 0, __n - 1, typename is_integral<_UResult_type>::type()); } /** * Inserts a %uniform_int random number distribution @p __x into the * output stream @p os. * * @param __os An output stream. * @param __x A %uniform_int random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_int<_IntType1>& __x); /** * Extracts a %uniform_int random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %uniform_int random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_int<_IntType1>& __x); private: template result_type _M_call(_UniformRandomNumberGenerator& __urng, result_type __min, result_type __max, true_type); template result_type _M_call(_UniformRandomNumberGenerator& __urng, result_type __min, result_type __max, false_type) { return result_type((__urng() - __urng.min()) / (__urng.max() - __urng.min()) * (__max - __min + 1)) + __min; } _IntType _M_min; _IntType _M_max; }; /** * @brief A Bernoulli random number distribution. * * Generates a sequence of true and false values with likelihood @f$ p @f$ * that true will come up and @f$ (1 - p) @f$ that false will appear. */ class bernoulli_distribution { public: typedef int input_type; typedef bool result_type; public: /** * Constructs a Bernoulli distribution with likelihood @p p. * * @param __p [IN] The likelihood of a true result being returned. Must * be in the interval @f$ [0, 1] @f$. */ explicit bernoulli_distribution(double __p = 0.5) : _M_p(__p) { _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0)); } /** * Gets the @p p parameter of the distribution. */ double p() const { return _M_p; } /** * Resets the distribution state. * * Does nothing for a Bernoulli distribution. */ void reset() { } /** * Gets the next value in the Bernoullian sequence. */ template result_type operator()(_UniformRandomNumberGenerator& __urng) { if ((__urng() - __urng.min()) < _M_p * (__urng.max() - __urng.min())) return true; return false; } /** * Inserts a %bernoulli_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %bernoulli_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x); /** * Extracts a %bernoulli_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %bernoulli_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x) { return __is >> __x._M_p; } private: double _M_p; }; /** * @brief A discrete geometric random number distribution. * * The formula for the geometric probability mass function is * @f$ p(i) = (1 - p)p^{i-1} @f$ where @f$ p @f$ is the parameter of the * distribution. */ template class geometric_distribution { public: // types typedef _RealType input_type; typedef _IntType result_type; // constructors and member function explicit geometric_distribution(const _RealType& __p = _RealType(0.5)) : _M_p(__p) { _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0)); _M_initialize(); } /** * Gets the distribution parameter @p p. */ _RealType p() const { return _M_p; } void reset() { } template result_type operator()(_UniformRandomNumberGenerator& __urng); /** * Inserts a %geometric_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %geometric_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const geometric_distribution<_IntType1, _RealType1>& __x); /** * Extracts a %geometric_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %geometric_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, geometric_distribution& __x) { __is >> __x._M_p; __x._M_initialize(); return __is; } private: void _M_initialize() { _M_log_p = std::log(_M_p); } _RealType _M_p; _RealType _M_log_p; }; template class normal_distribution; /** * @brief A discrete Poisson random number distribution. * * The formula for the Poisson probability mass function is * @f$ p(i) = \frac{mean^i}{i!} e^{-mean} @f$ where @f$ mean @f$ is the * parameter of the distribution. */ template class poisson_distribution { public: // types typedef _RealType input_type; typedef _IntType result_type; // constructors and member function explicit poisson_distribution(const _RealType& __mean = _RealType(1)) : _M_mean(__mean), _M_nd() { _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0); _M_initialize(); } /** * Gets the distribution parameter @p mean. */ _RealType mean() const { return _M_mean; } void reset() { _M_nd.reset(); } template result_type operator()(_UniformRandomNumberGenerator& __urng); /** * Inserts a %poisson_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %poisson_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const poisson_distribution<_IntType1, _RealType1>& __x); /** * Extracts a %poisson_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %poisson_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, poisson_distribution<_IntType1, _RealType1>& __x); private: void _M_initialize(); // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. normal_distribution<_RealType> _M_nd; _RealType _M_mean; // Hosts either log(mean) or the threshold of the simple method. _RealType _M_lm_thr; #if _GLIBCXX_USE_C99_MATH_TR1 _RealType _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb; #endif }; /** * @brief A discrete binomial random number distribution. * * The formula for the binomial probability mass function is * @f$ p(i) = \binom{n}{i} p^i (1 - p)^{t - i} @f$ where @f$ t @f$ * and @f$ p @f$ are the parameters of the distribution. */ template class binomial_distribution { public: // types typedef _RealType input_type; typedef _IntType result_type; // constructors and member function explicit binomial_distribution(_IntType __t = 1, const _RealType& __p = _RealType(0.5)) : _M_t(__t), _M_p(__p), _M_nd() { _GLIBCXX_DEBUG_ASSERT((_M_t >= 0) && (_M_p >= 0.0) && (_M_p <= 1.0)); _M_initialize(); } /** * Gets the distribution @p t parameter. */ _IntType t() const { return _M_t; } /** * Gets the distribution @p p parameter. */ _RealType p() const { return _M_p; } void reset() { _M_nd.reset(); } template result_type operator()(_UniformRandomNumberGenerator& __urng); /** * Inserts a %binomial_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %binomial_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const binomial_distribution<_IntType1, _RealType1>& __x); /** * Extracts a %binomial_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %binomial_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, binomial_distribution<_IntType1, _RealType1>& __x); private: void _M_initialize(); template result_type _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t); // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. normal_distribution<_RealType> _M_nd; _RealType _M_q; #if _GLIBCXX_USE_C99_MATH_TR1 _RealType _M_d1, _M_d2, _M_s1, _M_s2, _M_c, _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p; #endif _RealType _M_p; _IntType _M_t; bool _M_easy; }; /* @} */ // group tr1_random_distributions_discrete /** * @addtogroup tr1_random_distributions_continuous Continuous Distributions * @ingroup tr1_random_distributions * @{ */ /** * @brief Uniform continuous distribution for random numbers. * * A continuous random distribution on the range [min, max) with equal * probability throughout the range. The URNG should be real-valued and * deliver number in the range [0, 1). */ template class uniform_real { public: // types typedef _RealType input_type; typedef _RealType result_type; public: /** * Constructs a uniform_real object. * * @param __min [IN] The lower bound of the distribution. * @param __max [IN] The upper bound of the distribution. */ explicit uniform_real(_RealType __min = _RealType(0), _RealType __max = _RealType(1)) : _M_min(__min), _M_max(__max) { _GLIBCXX_DEBUG_ASSERT(_M_min <= _M_max); } result_type min() const { return _M_min; } result_type max() const { return _M_max; } void reset() { } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return (__urng() * (_M_max - _M_min)) + _M_min; } /** * Inserts a %uniform_real random number distribution @p __x into the * output stream @p __os. * * @param __os An output stream. * @param __x A %uniform_real random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_real<_RealType1>& __x); /** * Extracts a %uniform_real random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %uniform_real random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_real<_RealType1>& __x); private: _RealType _M_min; _RealType _M_max; }; /** * @brief An exponential continuous distribution for random numbers. * * The formula for the exponential probability mass function is * @f$ p(x) = \lambda e^{-\lambda x} @f$. * * * * * * * * *
Distribution Statistics
Mean@f$ \frac{1}{\lambda} @f$
Median@f$ \frac{\ln 2}{\lambda} @f$
Mode@f$ zero @f$
Range@f$[0, \infty]@f$
Standard Deviation@f$ \frac{1}{\lambda} @f$
*/ template class exponential_distribution { public: // types typedef _RealType input_type; typedef _RealType result_type; public: /** * Constructs an exponential distribution with inverse scale parameter * @f$ \lambda @f$. */ explicit exponential_distribution(const result_type& __lambda = result_type(1)) : _M_lambda(__lambda) { _GLIBCXX_DEBUG_ASSERT(_M_lambda > 0); } /** * Gets the inverse scale parameter of the distribution. */ _RealType lambda() const { return _M_lambda; } /** * Resets the distribution. * * Has no effect on exponential distributions. */ void reset() { } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return -std::log(__urng()) / _M_lambda; } /** * Inserts a %exponential_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %exponential_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const exponential_distribution<_RealType1>& __x); /** * Extracts a %exponential_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %exponential_distribution random number * generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, exponential_distribution& __x) { return __is >> __x._M_lambda; } private: result_type _M_lambda; }; /** * @brief A normal continuous distribution for random numbers. * * The formula for the normal probability mass function is * @f$ p(x) = \frac{1}{\sigma \sqrt{2 \pi}} * e^{- \frac{{x - mean}^ {2}}{2 \sigma ^ {2}} } @f$. */ template class normal_distribution { public: // types typedef _RealType input_type; typedef _RealType result_type; public: /** * Constructs a normal distribution with parameters @f$ mean @f$ and * @f$ \sigma @f$. */ explicit normal_distribution(const result_type& __mean = result_type(0), const result_type& __sigma = result_type(1)) : _M_mean(__mean), _M_sigma(__sigma), _M_saved_available(false) { _GLIBCXX_DEBUG_ASSERT(_M_sigma > 0); } /** * Gets the mean of the distribution. */ _RealType mean() const { return _M_mean; } /** * Gets the @f$ \sigma @f$ of the distribution. */ _RealType sigma() const { return _M_sigma; } /** * Resets the distribution. */ void reset() { _M_saved_available = false; } template result_type operator()(_UniformRandomNumberGenerator& __urng); /** * Inserts a %normal_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %normal_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RealType1>& __x); /** * Extracts a %normal_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %normal_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, normal_distribution<_RealType1>& __x); private: result_type _M_mean; result_type _M_sigma; result_type _M_saved; bool _M_saved_available; }; /** * @brief A gamma continuous distribution for random numbers. * * The formula for the gamma probability mass function is * @f$ p(x) = \frac{1}{\Gamma(\alpha)} x^{\alpha - 1} e^{-x} @f$. */ template class gamma_distribution { public: // types typedef _RealType input_type; typedef _RealType result_type; public: /** * Constructs a gamma distribution with parameters @f$ \alpha @f$. */ explicit gamma_distribution(const result_type& __alpha_val = result_type(1)) : _M_alpha(__alpha_val) { _GLIBCXX_DEBUG_ASSERT(_M_alpha > 0); _M_initialize(); } /** * Gets the @f$ \alpha @f$ of the distribution. */ _RealType alpha() const { return _M_alpha; } /** * Resets the distribution. */ void reset() { } template result_type operator()(_UniformRandomNumberGenerator& __urng); /** * Inserts a %gamma_distribution random number distribution * @p __x into the output stream @p __os. * * @param __os An output stream. * @param __x A %gamma_distribution random number distribution. * * @returns The output stream with the state of @p __x inserted or in * an error state. */ template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const gamma_distribution<_RealType1>& __x); /** * Extracts a %gamma_distribution random number distribution * @p __x from the input stream @p __is. * * @param __is An input stream. * @param __x A %gamma_distribution random number generator engine. * * @returns The input stream with @p __x extracted or in an error state. */ template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, gamma_distribution& __x) { __is >> __x._M_alpha; __x._M_initialize(); return __is; } private: void _M_initialize(); result_type _M_alpha; // Hosts either lambda of GB or d of modified Vaduva's. result_type _M_l_d; }; /* @} */ // group tr1_random_distributions_continuous /* @} */ // group tr1_random_distributions /* @} */ // group tr1_random } _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_RANDOM_H c++/8/tr1/special_function_util.h000064400000011677152640040210012532 0ustar00// Special functions -*- C++ -*- // Copyright (C) 2006-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tr1/special_function_util.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{tr1/cmath} */ // // ISO C++ 14882 TR1: 5.2 Special functions // // Written by Edward Smith-Rowland based on numerous mathematics books. #ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H #define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_STD_SPEC_FUNCS #elif defined(_GLIBCXX_TR1_CMATH) namespace tr1 { #else # error do not include this header directly, use or #endif namespace __detail { /// A class to encapsulate type dependent floating point /// constants. Not everything will be able to be expressed as /// type logic. template struct __floating_point_constant { static const _Tp __value; }; /// A structure for numeric constants. template struct __numeric_constants { /// Constant @f$ \pi @f$. static _Tp __pi() throw() { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } /// Constant @f$ \pi / 2 @f$. static _Tp __pi_2() throw() { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } /// Constant @f$ \pi / 3 @f$. static _Tp __pi_3() throw() { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } /// Constant @f$ \pi / 4 @f$. static _Tp __pi_4() throw() { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } /// Constant @f$ 1 / \pi @f$. static _Tp __1_pi() throw() { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } /// Constant @f$ 2 / \sqrt(\pi) @f$. static _Tp __2_sqrtpi() throw() { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } /// Constant @f$ \sqrt(2) @f$. static _Tp __sqrt2() throw() { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } /// Constant @f$ \sqrt(3) @f$. static _Tp __sqrt3() throw() { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } /// Constant @f$ \sqrt(\pi/2) @f$. static _Tp __sqrtpio2() throw() { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } /// Constant @f$ 1 / sqrt(2) @f$. static _Tp __sqrt1_2() throw() { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } /// Constant @f$ \log(\pi) @f$. static _Tp __lnpi() throw() { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } /// Constant Euler's constant @f$ \gamma_E @f$. static _Tp __gamma_e() throw() { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } /// Constant Euler-Mascheroni @f$ e @f$ static _Tp __euler() throw() { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } }; #if _GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC /// This is a wrapper for the isnan function. Otherwise, for NaN, /// all comparisons result in false. If/when we build a std::isnan /// out of intrinsics, this will disappear completely in favor of /// std::isnan. template inline bool __isnan(_Tp __x) { return std::isnan(__x); } #else template inline bool __isnan(const _Tp __x) { return __builtin_isnan(__x); } template<> inline bool __isnan(float __x) { return __builtin_isnanf(__x); } template<> inline bool __isnan(long double __x) { return __builtin_isnanl(__x); } #endif } // namespace __detail #if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH) } // namespace tr1 #endif _GLIBCXX_END_NAMESPACE_VERSION } #endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H c++/8/limits000064400000207075152640040210006514 0ustar00// The template and inlines for the numeric_limits classes. -*- C++ -*- // Copyright (C) 1999-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/limits * This is a Standard C++ Library header. */ // Note: this is not a conforming implementation. // Written by Gabriel Dos Reis // // ISO 14882:1998 // 18.2.1 // #ifndef _GLIBCXX_NUMERIC_LIMITS #define _GLIBCXX_NUMERIC_LIMITS 1 #pragma GCC system_header #include // // The numeric_limits<> traits document implementation-defined aspects // of fundamental arithmetic data types (integers and floating points). // From Standard C++ point of view, there are 14 such types: // * integers // bool (1) // char, signed char, unsigned char, wchar_t (4) // short, unsigned short (2) // int, unsigned (2) // long, unsigned long (2) // // * floating points // float (1) // double (1) // long double (1) // // GNU C++ understands (where supported by the host C-library) // * integer // long long, unsigned long long (2) // // which brings us to 16 fundamental arithmetic data types in GNU C++. // // // Since a numeric_limits<> is a bit tricky to get right, we rely on // an interface composed of macros which should be defined in config/os // or config/cpu when they differ from the generic (read arbitrary) // definitions given here. // // These values can be overridden in the target configuration file. // The default values are appropriate for many 32-bit targets. // GCC only intrinsically supports modulo integral types. The only remaining // integral exceptional values is division by zero. Only targets that do not // signal division by zero in some "hard to ignore" way should use false. #ifndef __glibcxx_integral_traps # define __glibcxx_integral_traps true #endif // float // // Default values. Should be overridden in configuration files if necessary. #ifndef __glibcxx_float_has_denorm_loss # define __glibcxx_float_has_denorm_loss false #endif #ifndef __glibcxx_float_traps # define __glibcxx_float_traps false #endif #ifndef __glibcxx_float_tinyness_before # define __glibcxx_float_tinyness_before false #endif // double // Default values. Should be overridden in configuration files if necessary. #ifndef __glibcxx_double_has_denorm_loss # define __glibcxx_double_has_denorm_loss false #endif #ifndef __glibcxx_double_traps # define __glibcxx_double_traps false #endif #ifndef __glibcxx_double_tinyness_before # define __glibcxx_double_tinyness_before false #endif // long double // Default values. Should be overridden in configuration files if necessary. #ifndef __glibcxx_long_double_has_denorm_loss # define __glibcxx_long_double_has_denorm_loss false #endif #ifndef __glibcxx_long_double_traps # define __glibcxx_long_double_traps false #endif #ifndef __glibcxx_long_double_tinyness_before # define __glibcxx_long_double_tinyness_before false #endif // You should not need to define any macros below this point. #define __glibcxx_signed_b(T,B) ((T)(-1) < 0) #define __glibcxx_min_b(T,B) \ (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0) #define __glibcxx_max_b(T,B) \ (__glibcxx_signed_b (T,B) ? \ (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0) #define __glibcxx_digits_b(T,B) \ (B - __glibcxx_signed_b (T,B)) // The fraction 643/2136 approximates log10(2) to 7 significant digits. #define __glibcxx_digits10_b(T,B) \ (__glibcxx_digits_b (T,B) * 643L / 2136) #define __glibcxx_signed(T) \ __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__) #define __glibcxx_min(T) \ __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__) #define __glibcxx_max(T) \ __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__) #define __glibcxx_digits(T) \ __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__) #define __glibcxx_digits10(T) \ __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__) #define __glibcxx_max_digits10(T) \ (2 + (T) * 643L / 2136) namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @brief Describes the rounding style for floating-point types. * * This is used in the std::numeric_limits class. */ enum float_round_style { round_indeterminate = -1, /// Intermediate. round_toward_zero = 0, /// To zero. round_to_nearest = 1, /// To the nearest representable value. round_toward_infinity = 2, /// To infinity. round_toward_neg_infinity = 3 /// To negative infinity. }; /** * @brief Describes the denormalization for floating-point types. * * These values represent the presence or absence of a variable number * of exponent bits. This type is used in the std::numeric_limits class. */ enum float_denorm_style { /// Indeterminate at compile time whether denormalized values are allowed. denorm_indeterminate = -1, /// The type does not allow denormalized values. denorm_absent = 0, /// The type allows denormalized values. denorm_present = 1 }; /** * @brief Part of std::numeric_limits. * * The @c static @c const members are usable as integral constant * expressions. * * @note This is a separate class for purposes of efficiency; you * should only access these members as part of an instantiation * of the std::numeric_limits class. */ struct __numeric_limits_base { /** This will be true for all fundamental types (which have specializations), and false for everything else. */ static _GLIBCXX_USE_CONSTEXPR bool is_specialized = false; /** The number of @c radix digits that be represented without change: for integer types, the number of non-sign bits in the mantissa; for floating types, the number of @c radix digits in the mantissa. */ static _GLIBCXX_USE_CONSTEXPR int digits = 0; /** The number of base 10 digits that can be represented without change. */ static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; #if __cplusplus >= 201103L /** The number of base 10 digits required to ensure that values which differ are always differentiated. */ static constexpr int max_digits10 = 0; #endif /** True if the type is signed. */ static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; /** True if the type is integer. */ static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; /** True if the type uses an exact representation. All integer types are exact, but not all exact types are integer. For example, rational and fixed-exponent representations are exact but not integer. */ static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; /** For integer types, specifies the base of the representation. For floating types, specifies the base of the exponent representation. */ static _GLIBCXX_USE_CONSTEXPR int radix = 0; /** The minimum negative integer such that @c radix raised to the power of (one less than that integer) is a normalized floating point number. */ static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; /** The minimum negative integer such that 10 raised to that power is in the range of normalized floating point numbers. */ static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; /** The maximum positive integer such that @c radix raised to the power of (one less than that integer) is a representable finite floating point number. */ static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; /** The maximum positive integer such that 10 raised to that power is in the range of representable finite floating point numbers. */ static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; /** True if the type has a representation for positive infinity. */ static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; /** True if the type has a representation for a quiet (non-signaling) Not a Number. */ static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; /** True if the type has a representation for a signaling Not a Number. */ static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; /** See std::float_denorm_style for more information. */ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; /** True if loss of accuracy is detected as a denormalization loss, rather than as an inexact result. */ static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; /** True if-and-only-if the type adheres to the IEC 559 standard, also known as IEEE 754. (Only makes sense for floating point types.) */ static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; /** True if the set of values representable by the type is finite. All built-in types are bounded, this member would be false for arbitrary precision types. */ static _GLIBCXX_USE_CONSTEXPR bool is_bounded = false; /** True if the type is @e modulo. A type is modulo if, for any operation involving +, -, or * on values of that type whose result would fall outside the range [min(),max()], the value returned differs from the true value by an integer multiple of max() - min() + 1. On most machines, this is false for floating types, true for unsigned integers, and true for signed integers. See PR22200 about signed integers. */ static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; /** True if trapping is implemented for this type. */ static _GLIBCXX_USE_CONSTEXPR bool traps = false; /** True if tininess is detected before rounding. (see IEC 559) */ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; /** See std::float_round_style for more information. This is only meaningful for floating types; integer types will all be round_toward_zero. */ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /** * @brief Properties of fundamental types. * * This class allows a program to obtain information about the * representation of a fundamental type on a given platform. For * non-fundamental types, the functions will return 0 and the data * members will all be @c false. */ template struct numeric_limits : public __numeric_limits_base { /** The minimum finite value, or for floating types with denormalization, the minimum positive normalized value. */ static _GLIBCXX_CONSTEXPR _Tp min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The maximum finite value. */ static _GLIBCXX_CONSTEXPR _Tp max() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } #if __cplusplus >= 201103L /** A finite value x such that there is no other finite value y * where y < x. */ static constexpr _Tp lowest() noexcept { return _Tp(); } #endif /** The @e machine @e epsilon: the difference between 1 and the least value greater than 1 that is representable. */ static _GLIBCXX_CONSTEXPR _Tp epsilon() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The maximum rounding error measurement (see LIA-1). */ static _GLIBCXX_CONSTEXPR _Tp round_error() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The representation of positive infinity, if @c has_infinity. */ static _GLIBCXX_CONSTEXPR _Tp infinity() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The representation of a quiet Not a Number, if @c has_quiet_NaN. */ static _GLIBCXX_CONSTEXPR _Tp quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The representation of a signaling Not a Number, if @c has_signaling_NaN. */ static _GLIBCXX_CONSTEXPR _Tp signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } /** The minimum positive denormalized value. For types where @c has_denorm is false, this is the minimum positive normalized value. */ static _GLIBCXX_CONSTEXPR _Tp denorm_min() _GLIBCXX_USE_NOEXCEPT { return _Tp(); } }; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 559. numeric_limits template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; // Now there follow 16 explicit specializations. Yes, 16. Make sure // you get the count right. (18 in C++11 mode, with char16_t and char32_t.) // _GLIBCXX_RESOLVE_LIB_DEFECTS // 184. numeric_limits wording problems /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR bool min() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_CONSTEXPR bool max() _GLIBCXX_USE_NOEXCEPT { return true; } #if __cplusplus >= 201103L static constexpr bool lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = 1; static _GLIBCXX_USE_CONSTEXPR int digits10 = 0; #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR bool epsilon() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_CONSTEXPR bool round_error() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR bool infinity() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_CONSTEXPR bool quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_CONSTEXPR bool signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_CONSTEXPR bool denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; // It is not clear what it means for a boolean type to trap. // This is a DR on the LWG issue list. Here, I use integer // promotion semantics. static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR char min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } static _GLIBCXX_CONSTEXPR char max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } #if __cplusplus >= 201103L static constexpr char lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (char); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (char); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (char); static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); } static _GLIBCXX_CONSTEXPR char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } static _GLIBCXX_CONSTEXPR char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } static _GLIBCXX_CONSTEXPR char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR signed char min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } static _GLIBCXX_CONSTEXPR signed char max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } #if __cplusplus >= 201103L static constexpr signed char lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (signed char); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR signed char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR signed char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR signed char infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR signed char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR signed char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR signed char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned char min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned char max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } #if __cplusplus >= 201103L static constexpr unsigned char lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned char); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned char); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned char infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR wchar_t min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } static _GLIBCXX_CONSTEXPR wchar_t max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } #if __cplusplus >= 201103L static constexpr wchar_t lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (wchar_t); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = __glibcxx_signed (wchar_t); static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR wchar_t epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR wchar_t round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR wchar_t infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } static _GLIBCXX_CONSTEXPR wchar_t quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } static _GLIBCXX_CONSTEXPR wchar_t signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } static _GLIBCXX_CONSTEXPR wchar_t denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = !is_signed; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; #if __cplusplus >= 201103L /// numeric_limits specialization. template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char16_t min() noexcept { return __glibcxx_min (char16_t); } static constexpr char16_t max() noexcept { return __glibcxx_max (char16_t); } static constexpr char16_t lowest() noexcept { return min(); } static constexpr int digits = __glibcxx_digits (char16_t); static constexpr int digits10 = __glibcxx_digits10 (char16_t); static constexpr int max_digits10 = 0; static constexpr bool is_signed = __glibcxx_signed (char16_t); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char16_t epsilon() noexcept { return 0; } static constexpr char16_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char16_t infinity() noexcept { return char16_t(); } static constexpr char16_t quiet_NaN() noexcept { return char16_t(); } static constexpr char16_t signaling_NaN() noexcept { return char16_t(); } static constexpr char16_t denorm_min() noexcept { return char16_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = __glibcxx_integral_traps; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char32_t min() noexcept { return __glibcxx_min (char32_t); } static constexpr char32_t max() noexcept { return __glibcxx_max (char32_t); } static constexpr char32_t lowest() noexcept { return min(); } static constexpr int digits = __glibcxx_digits (char32_t); static constexpr int digits10 = __glibcxx_digits10 (char32_t); static constexpr int max_digits10 = 0; static constexpr bool is_signed = __glibcxx_signed (char32_t); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char32_t epsilon() noexcept { return 0; } static constexpr char32_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char32_t infinity() noexcept { return char32_t(); } static constexpr char32_t quiet_NaN() noexcept { return char32_t(); } static constexpr char32_t signaling_NaN() noexcept { return char32_t(); } static constexpr char32_t denorm_min() noexcept { return char32_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = __glibcxx_integral_traps; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; #endif /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR short min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } static _GLIBCXX_CONSTEXPR short max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } #if __cplusplus >= 201103L static constexpr short lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (short); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (short); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR short epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR short round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR short infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } static _GLIBCXX_CONSTEXPR short quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } static _GLIBCXX_CONSTEXPR short signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } static _GLIBCXX_CONSTEXPR short denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned short min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned short max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } #if __cplusplus >= 201103L static constexpr unsigned short lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned short); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned short); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned short epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned short round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned short infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned short quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned short signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned short denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR int min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } static _GLIBCXX_CONSTEXPR int max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } #if __cplusplus >= 201103L static constexpr int lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (int); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (int); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR int epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR int round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR int infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR int quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR int signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR int denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned int min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned int max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } #if __cplusplus >= 201103L static constexpr unsigned int lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned int); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned int); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned int epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned int round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned int infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned int quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned int signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned int denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR long min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } static _GLIBCXX_CONSTEXPR long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } #if __cplusplus >= 201103L static constexpr long lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned long min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } #if __cplusplus >= 201103L static constexpr unsigned long lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned long); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR long long min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } static _GLIBCXX_CONSTEXPR long long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } #if __cplusplus >= 201103L static constexpr long long lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long long); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR long long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR long long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR long long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR long long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR unsigned long long min() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned long long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } #if __cplusplus >= 201103L static constexpr unsigned long long lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned long long); static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned long long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; static _GLIBCXX_CONSTEXPR unsigned long long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_CONSTEXPR unsigned long long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; static _GLIBCXX_CONSTEXPR unsigned long long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_CONSTEXPR unsigned long long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; #if !defined(__STRICT_ANSI__) #define __INT_N(TYPE, BITSIZE, EXT, UEXT) \ template<> \ struct numeric_limits \ { \ static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ \ static _GLIBCXX_CONSTEXPR TYPE \ min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min_b (TYPE, BITSIZE); } \ \ static _GLIBCXX_CONSTEXPR TYPE \ max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max_b (TYPE, BITSIZE); } \ \ static _GLIBCXX_USE_CONSTEXPR int digits \ = BITSIZE - 1; \ static _GLIBCXX_USE_CONSTEXPR int digits10 \ = (BITSIZE - 1) * 643L / 2136; \ \ static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; \ static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ \ static _GLIBCXX_CONSTEXPR TYPE \ epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ \ static _GLIBCXX_CONSTEXPR TYPE \ round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ \ EXT \ \ static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ \ static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ = denorm_absent; \ static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ \ static _GLIBCXX_CONSTEXPR TYPE \ infinity() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR TYPE \ quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR TYPE \ signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR TYPE \ denorm_min() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; \ \ static _GLIBCXX_USE_CONSTEXPR bool traps \ = __glibcxx_integral_traps; \ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ = round_toward_zero; \ }; \ \ template<> \ struct numeric_limits \ { \ static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ min() _GLIBCXX_USE_NOEXCEPT { return 0; } \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ max() _GLIBCXX_USE_NOEXCEPT \ { return __glibcxx_max_b (unsigned TYPE, BITSIZE); } \ \ UEXT \ \ static _GLIBCXX_USE_CONSTEXPR int digits \ = BITSIZE; \ static _GLIBCXX_USE_CONSTEXPR int digits10 \ = BITSIZE * 643L / 2136; \ static _GLIBCXX_USE_CONSTEXPR bool is_signed = false; \ static _GLIBCXX_USE_CONSTEXPR bool is_integer = true; \ static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; \ static _GLIBCXX_USE_CONSTEXPR int radix = 2; \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } \ \ static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; \ static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = 0; \ static _GLIBCXX_USE_CONSTEXPR int max_exponent = 0; \ static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = 0; \ \ static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; \ static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; \ static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; \ static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm \ = denorm_absent; \ static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ infinity() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ quiet_NaN() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ signaling_NaN() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_CONSTEXPR unsigned TYPE \ denorm_min() _GLIBCXX_USE_NOEXCEPT \ { return static_cast(0); } \ \ static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; \ static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; \ static _GLIBCXX_USE_CONSTEXPR bool is_modulo = true; \ \ static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; \ static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; \ static _GLIBCXX_USE_CONSTEXPR float_round_style round_style \ = round_toward_zero; \ }; #if __cplusplus >= 201103L #define __INT_N_201103(TYPE) \ static constexpr TYPE \ lowest() noexcept { return min(); } \ static constexpr int max_digits10 = 0; #define __INT_N_U201103(TYPE) \ static constexpr unsigned TYPE \ lowest() noexcept { return min(); } \ static constexpr int max_digits10 = 0; #else #define __INT_N_201103(TYPE) #define __INT_N_U201103(TYPE) #endif #ifdef __GLIBCXX_TYPE_INT_N_0 __INT_N(__GLIBCXX_TYPE_INT_N_0, __GLIBCXX_BITSIZE_INT_N_0, __INT_N_201103 (__GLIBCXX_TYPE_INT_N_0), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_0)) #endif #ifdef __GLIBCXX_TYPE_INT_N_1 __INT_N (__GLIBCXX_TYPE_INT_N_1, __GLIBCXX_BITSIZE_INT_N_1, __INT_N_201103 (__GLIBCXX_TYPE_INT_N_1), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_1)) #endif #ifdef __GLIBCXX_TYPE_INT_N_2 __INT_N (__GLIBCXX_TYPE_INT_N_2, __GLIBCXX_BITSIZE_INT_N_2, __INT_N_201103 (__GLIBCXX_TYPE_INT_N_2), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_2)) #endif #ifdef __GLIBCXX_TYPE_INT_N_3 __INT_N (__GLIBCXX_TYPE_INT_N_3, __GLIBCXX_BITSIZE_INT_N_3, __INT_N_201103 (__GLIBCXX_TYPE_INT_N_3), __INT_N_U201103 (__GLIBCXX_TYPE_INT_N_3)) #endif #undef __INT_N #undef __INT_N_201103 #undef __INT_N_U201103 #endif /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR float min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } static _GLIBCXX_CONSTEXPR float max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } #if __cplusplus >= 201103L static constexpr float lowest() noexcept { return -__FLT_MAX__; } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __FLT_MANT_DIG__; static _GLIBCXX_USE_CONSTEXPR int digits10 = __FLT_DIG__; #if __cplusplus >= 201103L static constexpr int max_digits10 = __glibcxx_max_digits10 (__FLT_MANT_DIG__); #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; static _GLIBCXX_CONSTEXPR float epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } static _GLIBCXX_CONSTEXPR float round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __FLT_MIN_10_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent = __FLT_MAX_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __FLT_MAX_10_EXP__; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __FLT_HAS_INFINITY__; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __FLT_HAS_QUIET_NAN__; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_float_has_denorm_loss; static _GLIBCXX_CONSTEXPR float infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } static _GLIBCXX_CONSTEXPR float quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } static _GLIBCXX_CONSTEXPR float signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } static _GLIBCXX_CONSTEXPR float denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_float_tinyness_before; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; #undef __glibcxx_float_has_denorm_loss #undef __glibcxx_float_traps #undef __glibcxx_float_tinyness_before /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR double min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } static _GLIBCXX_CONSTEXPR double max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } #if __cplusplus >= 201103L static constexpr double lowest() noexcept { return -__DBL_MAX__; } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __DBL_MANT_DIG__; static _GLIBCXX_USE_CONSTEXPR int digits10 = __DBL_DIG__; #if __cplusplus >= 201103L static constexpr int max_digits10 = __glibcxx_max_digits10 (__DBL_MANT_DIG__); #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; static _GLIBCXX_CONSTEXPR double epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } static _GLIBCXX_CONSTEXPR double round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __DBL_MIN_10_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent = __DBL_MAX_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __DBL_MAX_10_EXP__; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __DBL_HAS_INFINITY__; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __DBL_HAS_QUIET_NAN__; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_double_has_denorm_loss; static _GLIBCXX_CONSTEXPR double infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } static _GLIBCXX_CONSTEXPR double quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } static _GLIBCXX_CONSTEXPR double signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } static _GLIBCXX_CONSTEXPR double denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_double_tinyness_before; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; #undef __glibcxx_double_has_denorm_loss #undef __glibcxx_double_traps #undef __glibcxx_double_tinyness_before /// numeric_limits specialization. template<> struct numeric_limits { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; static _GLIBCXX_CONSTEXPR long double min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } static _GLIBCXX_CONSTEXPR long double max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } #if __cplusplus >= 201103L static constexpr long double lowest() noexcept { return -__LDBL_MAX__; } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __LDBL_MANT_DIG__; static _GLIBCXX_USE_CONSTEXPR int digits10 = __LDBL_DIG__; #if __cplusplus >= 201103L static _GLIBCXX_USE_CONSTEXPR int max_digits10 = __glibcxx_max_digits10 (__LDBL_MANT_DIG__); #endif static _GLIBCXX_USE_CONSTEXPR bool is_signed = true; static _GLIBCXX_USE_CONSTEXPR bool is_integer = false; static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; static _GLIBCXX_CONSTEXPR long double epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } static _GLIBCXX_CONSTEXPR long double round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; static _GLIBCXX_USE_CONSTEXPR int min_exponent10 = __LDBL_MIN_10_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent = __LDBL_MAX_EXP__; static _GLIBCXX_USE_CONSTEXPR int max_exponent10 = __LDBL_MAX_10_EXP__; static _GLIBCXX_USE_CONSTEXPR bool has_infinity = __LDBL_HAS_INFINITY__; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = __LDBL_HAS_QUIET_NAN__; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__LDBL_HAS_DENORM__) ? denorm_present : denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_long_double_has_denorm_loss; static _GLIBCXX_CONSTEXPR long double infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } static _GLIBCXX_CONSTEXPR long double quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } static _GLIBCXX_CONSTEXPR long double signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } static _GLIBCXX_CONSTEXPR long double denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static _GLIBCXX_USE_CONSTEXPR bool is_bounded = true; static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_long_double_tinyness_before; static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; #undef __glibcxx_long_double_has_denorm_loss #undef __glibcxx_long_double_traps #undef __glibcxx_long_double_tinyness_before _GLIBCXX_END_NAMESPACE_VERSION } // namespace #undef __glibcxx_signed #undef __glibcxx_min #undef __glibcxx_max #undef __glibcxx_digits #undef __glibcxx_digits10 #undef __glibcxx_max_digits10 #endif // _GLIBCXX_NUMERIC_LIMITS c++/8/deque000064400000005151152640040220006306 0ustar00// -*- C++ -*- // Copyright (C) 2001-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /** @file include/deque * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_DEQUE #define _GLIBCXX_DEQUE 1 #pragma GCC system_header #include #include #include #include #include #include #include #ifdef _GLIBCXX_DEBUG # include #endif #ifdef _GLIBCXX_PROFILE # include #endif #endif /* _GLIBCXX_DEQUE */ c++/8/new000064400000016541152640040220006001 0ustar00// The -*- C++ -*- dynamic memory management header. // Copyright (C) 1994-2018 Free Software Foundation, Inc. // This file is part of GCC. // // GCC is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3, or (at your option) // any later version. // // GCC 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 General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file new * This is a Standard C++ Library header. * * The header @c new defines several functions to manage dynamic memory and * handling memory allocation errors; see * http://gcc.gnu.org/onlinedocs/libstdc++/18_support/howto.html#4 for more. */ #ifndef _NEW #define _NEW #pragma GCC system_header #include #include #pragma GCC visibility push(default) extern "C++" { namespace std { /** * @brief Exception possibly thrown by @c new. * @ingroup exceptions * * @c bad_alloc (or classes derived from it) is used to report allocation * errors from the throwing forms of @c new. */ class bad_alloc : public exception { public: bad_alloc() throw() { } // This declaration is not useless: // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 virtual ~bad_alloc() throw(); // See comment in eh_exception.cc. virtual const char* what() const throw(); }; #if __cplusplus >= 201103L class bad_array_new_length : public bad_alloc { public: bad_array_new_length() throw() { } // This declaration is not useless: // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 virtual ~bad_array_new_length() throw(); // See comment in eh_exception.cc. virtual const char* what() const throw(); }; #endif #if __cpp_aligned_new enum class align_val_t: size_t {}; #endif struct nothrow_t { #if __cplusplus >= 201103L explicit nothrow_t() = default; #endif }; extern const nothrow_t nothrow; /** If you write your own error handler to be called by @c new, it must * be of this type. */ typedef void (*new_handler)(); /// Takes a replacement handler as the argument, returns the /// previous handler. new_handler set_new_handler(new_handler) throw(); #if __cplusplus >= 201103L /// Return the current new handler. new_handler get_new_handler() noexcept; #endif } // namespace std //@{ /** These are replaceable signatures: * - normal single new and delete (no arguments, throw @c bad_alloc on error) * - normal array new and delete (same) * - @c nothrow single new and delete (take a @c nothrow argument, return * @c NULL on error) * - @c nothrow array new and delete (same) * * Placement new and delete signatures (take a memory address argument, * does nothing) may not be replaced by a user's program. */ void* operator new(std::size_t) _GLIBCXX_THROW (std::bad_alloc) __attribute__((__externally_visible__)); void* operator new[](std::size_t) _GLIBCXX_THROW (std::bad_alloc) __attribute__((__externally_visible__)); void operator delete(void*) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); #if __cpp_sized_deallocation void operator delete(void*, std::size_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); #endif void* operator new(std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void* operator new[](std::size_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete(void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); #if __cpp_aligned_new void* operator new(std::size_t, std::align_val_t) __attribute__((__externally_visible__)); void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete(void*, std::align_val_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete(void*, std::align_val_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void* operator new[](std::size_t, std::align_val_t) __attribute__((__externally_visible__)); void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*, std::align_val_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*, std::align_val_t, const std::nothrow_t&) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); #if __cpp_sized_deallocation void operator delete(void*, std::size_t, std::align_val_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t, std::align_val_t) _GLIBCXX_USE_NOEXCEPT __attribute__((__externally_visible__)); #endif // __cpp_sized_deallocation #endif // __cpp_aligned_new // Default placement versions of operator new. inline void* operator new(std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT { return __p; } inline void* operator new[](std::size_t, void* __p) _GLIBCXX_USE_NOEXCEPT { return __p; } // Default placement versions of operator delete. inline void operator delete (void*, void*) _GLIBCXX_USE_NOEXCEPT { } inline void operator delete[](void*, void*) _GLIBCXX_USE_NOEXCEPT { } //@} } // extern "C++" #if __cplusplus >= 201703L #if __GNUC__ >= 7 # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1 #elif defined __has_builtin // For non-GNU compilers: # if __has_builtin(__builtin_launder) # define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1 # endif #endif #ifdef _GLIBCXX_HAVE_BUILTIN_LAUNDER namespace std { #define __cpp_lib_launder 201606 /// Pointer optimization barrier [ptr.launder] template [[nodiscard]] constexpr _Tp* launder(_Tp* __p) noexcept { return __builtin_launder(__p); } // The program is ill-formed if T is a function type or // (possibly cv-qualified) void. template void launder(_Ret (*)(_Args...) _GLIBCXX_NOEXCEPT_QUAL) = delete; template void launder(_Ret (*)(_Args......) _GLIBCXX_NOEXCEPT_QUAL) = delete; void launder(void*) = delete; void launder(const void*) = delete; void launder(volatile void*) = delete; void launder(const volatile void*) = delete; } #endif // _GLIBCXX_HAVE_BUILTIN_LAUNDER #undef _GLIBCXX_HAVE_BUILTIN_LAUNDER #endif // C++17 #pragma GCC visibility pop #endif c++/8/cinttypes000064400000004155152640040220007230 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/cinttypes * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_CINTTYPES #define _GLIBCXX_CINTTYPES 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include // For 27.9.2/3 (see C99, Note 184) #if _GLIBCXX_HAVE_INTTYPES_H # ifndef __STDC_FORMAT_MACROS # define _UNDEF__STDC_FORMAT_MACROS # define __STDC_FORMAT_MACROS # endif # include # ifdef _UNDEF__STDC_FORMAT_MACROS # undef __STDC_FORMAT_MACROS # undef _UNDEF__STDC_FORMAT_MACROS # endif #endif #ifdef _GLIBCXX_USE_C99_INTTYPES_TR1 namespace std { // types using ::imaxdiv_t; // functions using ::imaxabs; using ::imaxdiv; // GCC does not support extended integer types // intmax_t abs(intmax_t) // imaxdiv_t div(intmax_t, intmax_t) using ::strtoimax; using ::strtoumax; #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 using ::wcstoimax; using ::wcstoumax; #endif } // namespace std #endif // _GLIBCXX_USE_C99_INTTYPES_TR1 #endif // C++11 #endif // _GLIBCXX_CINTTYPES c++/8/profile/array000064400000021134152640040220007760 0ustar00// Profile array implementation -*- C++ -*- // Copyright (C) 2012-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/array * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_PROFILE_ARRAY #define _GLIBCXX_PROFILE_ARRAY 1 #pragma GCC system_header #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template struct array { typedef _Tp value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* iterator; typedef const value_type* const_iterator; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // Support for zero-sized arrays mandatory. typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type; typename _AT_Type::_Type _M_elems; // No explicit construct/copy/destroy for aggregate type. // DR 776. void fill(const value_type& __u) { std::fill_n(begin(), size(), __u); } void swap(array& __other) noexcept(_AT_Type::_Is_nothrow_swappable::value) { std::swap_ranges(begin(), end(), __other.begin()); } // Iterators. _GLIBCXX17_CONSTEXPR iterator begin() noexcept { return iterator(data()); } _GLIBCXX17_CONSTEXPR const_iterator begin() const noexcept { return const_iterator(data()); } _GLIBCXX17_CONSTEXPR iterator end() noexcept { return iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR const_iterator end() const noexcept { return const_iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR reverse_iterator rend() noexcept { return reverse_iterator(begin()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } _GLIBCXX17_CONSTEXPR const_iterator cbegin() const noexcept { return const_iterator(data()); } _GLIBCXX17_CONSTEXPR const_iterator cend() const noexcept { return const_iterator(data() + _Nm); } _GLIBCXX17_CONSTEXPR const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } _GLIBCXX17_CONSTEXPR const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } // Capacity. constexpr size_type size() const noexcept { return _Nm; } constexpr size_type max_size() const noexcept { return _Nm; } constexpr bool empty() const noexcept { return size() == 0; } // Element access. reference operator[](size_type __n) noexcept { return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference operator[](size_type __n) const noexcept { return _AT_Type::_S_ref(_M_elems, __n); } _GLIBCXX17_CONSTEXPR reference at(size_type __n) { if (__n >= _Nm) std::__throw_out_of_range_fmt(__N("array::at: __n " "(which is %zu) >= _Nm " "(which is %zu)"), __n, _Nm); return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference at(size_type __n) const { // Result of conditional expression must be an lvalue so use // boolean ? lvalue : (throw-expr, lvalue) return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), __n, _Nm), _AT_Type::_S_ref(_M_elems, 0)); } _GLIBCXX17_CONSTEXPR reference front() noexcept { return *begin(); } constexpr const_reference front() const noexcept { return _AT_Type::_S_ref(_M_elems, 0); } _GLIBCXX17_CONSTEXPR reference back() noexcept { return _Nm ? *(end() - 1) : *end(); } constexpr const_reference back() const noexcept { return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) : _AT_Type::_S_ref(_M_elems, 0); } _GLIBCXX17_CONSTEXPR pointer data() noexcept { return _AT_Type::_S_ptr(_M_elems); } _GLIBCXX17_CONSTEXPR const_pointer data() const noexcept { return _AT_Type::_S_ptr(_M_elems); } }; // Array comparisons. template inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } template inline bool operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one == __two); } template inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) { return std::lexicographical_compare(__a.begin(), __a.end(), __b.begin(), __b.end()); } template inline bool operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return __two < __one; } template inline bool operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one > __two); } template inline bool operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return !(__one < __two); } // Specialized algorithms. template inline void swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two))) { __one.swap(__two); } template constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "index is out of bounds"); return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } template constexpr _Tp&& get(array<_Tp, _Nm>&& __arr) noexcept { static_assert(_Int < _Nm, "index is out of bounds"); return std::move(__profile::get<_Int>(__arr)); } template constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "index is out of bounds"); return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } } // namespace __profile _GLIBCXX_BEGIN_NAMESPACE_VERSION // Tuple interface to class template array. /// tuple_size template struct tuple_size> : public integral_constant { }; /// tuple_element template struct tuple_element<_Int, std::__profile::array<_Tp, _Nm>> { static_assert(_Int < _Nm, "index is out of bounds"); typedef _Tp type; }; template struct __is_tuple_like_impl> : true_type { }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // _GLIBCXX_PROFILE_ARRAY c++/8/profile/ordered_base.h000064400000005330152640040220011506 0ustar00// Profiling unordered containers implementation details -*- C++ -*- // Copyright (C) 2014-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/ordered_base.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_ORDERED #define _GLIBCXX_PROFILE_ORDERED 1 namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template class _Ordered_profile { public: void _M_profile_iterate(int __rewind = 0) const { __profcxx_map2umap_iterate(this->_M_map2umap_info, __rewind); } protected: _Ordered_profile() _GLIBCXX_NOEXCEPT { _M_profile_construct(); } #if __cplusplus >= 201103L _Ordered_profile(const _Ordered_profile&) noexcept : _Ordered_profile() { } _Ordered_profile(_Ordered_profile&& __other) noexcept : _Ordered_profile() { _M_swap(__other); } _Ordered_profile& operator=(const _Ordered_profile&) noexcept { _M_profile_destruct(); _M_profile_construct(); } _Ordered_profile& operator=(_Ordered_profile&& __other) noexcept { _M_swap(__other); __other._M_profile_destruct(); __other._M_profile_construct(); } #endif ~_Ordered_profile() { _M_profile_destruct(); } void _M_profile_construct() _GLIBCXX_NOEXCEPT { _M_map2umap_info = __profcxx_map2umap_construct(); } void _M_profile_destruct() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_destruct(_M_map2umap_info); _M_map2umap_info = 0; } void _M_swap(_Ordered_profile& __other) { std::swap(_M_map2umap_info, __other._M_map2umap_info); } __gnu_profile::__map2umap_info* _M_map2umap_info; private: _Cont& _M_conjure() { return *static_cast<_Cont*>(this); } }; } // namespace __profile } // namespace std #endif c++/8/profile/impl/profiler_node.h000064400000007331152640040220012663 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_node.h * @brief Data structures to represent a single profiling event. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_NODE_H #define _GLIBCXX_PROFILE_PROFILER_NODE_H 1 #include // FILE, fprintf #include #if defined _GLIBCXX_HAVE_EXECINFO_H #include #endif namespace __gnu_profile { typedef void* __instruction_address_t; typedef std::_GLIBCXX_STD_C::vector<__instruction_address_t> __stack_npt; typedef __stack_npt* __stack_t; std::size_t __stack_max_depth(); inline __stack_t __get_stack() { #if defined _GLIBCXX_HAVE_EXECINFO_H __try { std::size_t __max_depth = __stack_max_depth(); if (__max_depth == 0) return 0; __stack_npt __buffer(__max_depth); int __depth = backtrace(&__buffer[0], __max_depth); return new(std::nothrow) __stack_npt(__buffer.begin(), __buffer.begin() + __depth); } __catch(...) { return 0; } #else return 0; #endif } inline std::size_t __size(__stack_t __stack) { if (!__stack) return 0; else return __stack->size(); } // XXX inline void __write(FILE* __f, __stack_t __stack) { if (!__stack) return; __stack_npt::const_iterator __it; for (__it = __stack->begin(); __it != __stack->end(); ++__it) std::fprintf(__f, "%p ", *__it); } /** @brief Hash function for summary trace using call stack as index. */ class __stack_hash { public: std::size_t operator()(__stack_t __s) const { if (!__s) return 0; std::size_t __index = 0; __stack_npt::const_iterator __it; for (__it = __s->begin(); __it != __s->end(); ++__it) __index += reinterpret_cast(*__it); return __index; } bool operator() (__stack_t __stack1, __stack_t __stack2) const { if (!__stack1 && !__stack2) return true; if (!__stack1 || !__stack2) return false; if (__stack1->size() != __stack2->size()) return false; std::size_t __byte_size = __stack1->size() * sizeof(__stack_npt::value_type); return __builtin_memcmp(&(*__stack1)[0], &(*__stack2)[0], __byte_size) == 0; } }; /** @brief Base class for a line in the object table. */ class __object_info_base { public: __object_info_base(__stack_t __stack) : _M_stack(__stack), _M_valid(true) { } bool __is_valid() const { return _M_valid; } void __set_invalid() { _M_valid = false; } void __merge(const __object_info_base& __o) { _M_valid &= __o._M_valid; } __stack_t __stack() const { return _M_stack; } protected: __stack_t _M_stack; bool _M_valid; }; } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_NODE_H */ c++/8/profile/impl/profiler_state.h000064400000003724152640040220013060 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_state.h * @brief Global profiler state. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_STATE_H #define _GLIBCXX_PROFILE_PROFILER_STATE_H 1 namespace __gnu_profile { enum __state_type { __ON, __OFF, __INVALID }; _GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID); inline bool __turn(__state_type __s) { __state_type inv(__INVALID); return __atomic_compare_exchange_n(&_GLIBCXX_PROFILE_DATA(__state), &inv, __s, false, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED); } inline bool __turn_on() { return __turn(__ON); } inline bool __turn_off() { return __turn(__OFF); } inline bool __is_on() { return _GLIBCXX_PROFILE_DATA(__state) == __ON; } inline bool __is_off() { return _GLIBCXX_PROFILE_DATA(__state) == __OFF; } inline bool __is_invalid() { return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; } } // end namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_STATE_H */ c++/8/profile/impl/profiler_list_to_vector.h000064400000015273152640040220015001 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_list_to_vector.h * @brief diagnostics for list to vector. */ // Written by Changhee Jung. #ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H #define _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H 1 #include #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { /** @brief A list-to-vector instrumentation line in the object table. */ class __list2vector_info : public __object_info_base { public: __list2vector_info(__stack_t __stack) : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_max_size(0) { } void __merge(const __list2vector_info& __o) { __object_info_base::__merge(__o); _M_shift_count += __o._M_shift_count; _M_iterate += __o._M_iterate; _M_vector_cost += __o._M_vector_cost; _M_list_cost += __o._M_list_cost; _M_resize += __o._M_resize; _M_max_size = std::max( _M_max_size, __o._M_max_size); } void __write(FILE* __f) const { std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); } float __magnitude() const { return _M_list_cost - _M_vector_cost; } std::string __advice() const { std::stringstream __sstream; __sstream << "change std::list to std::vector and its initial size from 0 to " << _M_max_size; return __sstream.str(); } std::size_t __shift_count() { return _M_shift_count; } std::size_t __iterate() { return _M_iterate; } float __list_cost() { return _M_list_cost; } std::size_t __resize() { return _M_resize; } void __set_list_cost(float __lc) { _M_list_cost = __lc; } void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } void __opr_insert(std::size_t __shift, std::size_t __size) { _M_shift_count += __shift; _M_max_size = std::max(_M_max_size, __size); } void __opr_iterate(int __num) { __gnu_cxx::__atomic_add(&_M_iterate, __num); } void __resize(std::size_t __from, std::size_t) { _M_resize += __from; } private: std::size_t _M_shift_count; mutable _Atomic_word _M_iterate; std::size_t _M_resize; float _M_list_cost; float _M_vector_cost; std::size_t _M_max_size; }; class __list2vector_stack_info : public __list2vector_info { public: __list2vector_stack_info(const __list2vector_info& __o) : __list2vector_info(__o) {} }; class __trace_list_to_vector : public __trace_base<__list2vector_info, __list2vector_stack_info> { public: __trace_list_to_vector() : __trace_base<__list2vector_info, __list2vector_stack_info>() { __id = "list-to-vector"; } ~__trace_list_to_vector() { } // Call at destruction/clean to set container final size. void __destruct(__list2vector_info* __obj_info) { float __vc = __vector_cost(__obj_info->__shift_count(), __obj_info->__iterate()); float __lc = __list_cost(__obj_info->__shift_count(), __obj_info->__iterate()); __obj_info->__set_vector_cost(__vc); __obj_info->__set_list_cost(__lc); __retire_object(__obj_info); } // Collect cost of operations. float __vector_cost(std::size_t __shift, std::size_t __iterate) { // The resulting vector will use a 'reserve' method. return (__shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value); } float __list_cost(std::size_t __shift, std::size_t __iterate) { return (__shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value); } }; inline void __trace_list_to_vector_init() { _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); } inline void __trace_list_to_vector_free() { delete _GLIBCXX_PROFILE_DATA(_S_list_to_vector); } inline void __trace_list_to_vector_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_list_to_vector), __f, __warnings); } inline __list2vector_info* __trace_list_to_vector_construct() { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_list_to_vector) ->__add_object(__get_stack()); } inline void __trace_list_to_vector_insert(__list2vector_info* __obj_info, std::size_t __shift, std::size_t __size) { if (!__obj_info) return; __obj_info->__opr_insert(__shift, __size); } inline void __trace_list_to_vector_iterate(__list2vector_info* __obj_info, int) { if (!__obj_info) return; // We only collect if an iteration took place no matter in what side. __obj_info->__opr_iterate(1); } inline void __trace_list_to_vector_invalid_operator(__list2vector_info* __obj_info) { if (!__obj_info) return; __obj_info->__set_invalid(); } inline void __trace_list_to_vector_resize(__list2vector_info* __obj_info, std::size_t __from, std::size_t __to) { if (!__obj_info) return; __obj_info->__resize(__from, __to); } inline void __trace_list_to_vector_destruct(__list2vector_info* __obj_info) { if (!__obj_info) return; _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj_info); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H__ */ c++/8/profile/impl/profiler.h000064400000033144152640040220011657 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler.h * @brief Interface of the profiling runtime library. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_H #define _GLIBCXX_PROFILE_PROFILER_H 1 #include // Mechanism to define data with inline linkage. #define _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__type, __name) \ inline __type& \ __get_##__name() \ { \ static __type __name; \ return __name; \ } #define _GLIBCXX_PROFILE_DEFINE_DATA(__type, __name, __initial_value...) \ inline __type& __get_##__name() { \ static __type __name(__initial_value); \ return __name; \ } #define _GLIBCXX_PROFILE_DATA(__name) \ __get_##__name() namespace __gnu_profile { /** @brief Reentrance guard. * * Mechanism to protect all __gnu_profile operations against recursion, * multithreaded and exception reentrance. */ struct __reentrance_guard { static bool __get_in() { if (__inside() == true) return false; else { __inside() = true; return true; } } static bool& __inside() { static __thread bool _S_inside(false); return _S_inside; } __reentrance_guard() { } ~__reentrance_guard() { __inside() = false; } }; // Forward declarations of implementation functions. // Don't use any __gnu_profile:: in user code. // Instead, use the __profcxx... macros, which offer guarded access. class __container_size_info; class __hashfunc_info; class __map2umap_info; class __vector2list_info; class __list2slist_info; class __list2vector_info; bool __turn_on(); bool __turn_off(); bool __is_invalid(); bool __is_on(); bool __is_off(); void __report(); __container_size_info* __trace_hashtable_size_construct(std::size_t); void __trace_hashtable_size_resize(__container_size_info*, std::size_t, std::size_t); void __trace_hashtable_size_destruct(__container_size_info*, std::size_t, std::size_t); __hashfunc_info* __trace_hash_func_construct(); void __trace_hash_func_destruct(__hashfunc_info*, std::size_t, std::size_t, std::size_t); __container_size_info* __trace_vector_size_construct(std::size_t); void __trace_vector_size_resize(__container_size_info*, std::size_t, std::size_t); void __trace_vector_size_destruct(__container_size_info*, std::size_t, std::size_t); __vector2list_info* __trace_vector_to_list_construct(); void __trace_vector_to_list_insert(__vector2list_info*, std::size_t, std::size_t); void __trace_vector_to_list_iterate(__vector2list_info*, int); void __trace_vector_to_list_invalid_operator(__vector2list_info*); void __trace_vector_to_list_resize(__vector2list_info*, std::size_t, std::size_t); void __trace_vector_to_list_destruct(__vector2list_info*); __list2slist_info* __trace_list_to_slist_construct(); void __trace_list_to_slist_rewind(__list2slist_info*); void __trace_list_to_slist_operation(__list2slist_info*); void __trace_list_to_slist_destruct(__list2slist_info*); __list2vector_info* __trace_list_to_vector_construct(); void __trace_list_to_vector_insert(__list2vector_info*, std::size_t, std::size_t); void __trace_list_to_vector_iterate(__list2vector_info*, int); void __trace_list_to_vector_invalid_operator(__list2vector_info*); void __trace_list_to_vector_resize(__list2vector_info*, std::size_t, std::size_t); void __trace_list_to_vector_destruct(__list2vector_info*); __map2umap_info* __trace_map_to_unordered_map_construct(); void __trace_map_to_unordered_map_invalidate(__map2umap_info*); void __trace_map_to_unordered_map_insert(__map2umap_info*, std::size_t, std::size_t); void __trace_map_to_unordered_map_erase(__map2umap_info*, std::size_t, std::size_t); void __trace_map_to_unordered_map_iterate(__map2umap_info*, std::size_t); void __trace_map_to_unordered_map_find(__map2umap_info*, std::size_t); void __trace_map_to_unordered_map_destruct(__map2umap_info*); } // namespace __gnu_profile // Master switch turns on all diagnostics that are not explicitly turned off. #ifdef _GLIBCXX_PROFILE #ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_SMALL #define _GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL #endif #ifndef _GLIBCXX_PROFILE_NO_HASHTABLE_TOO_LARGE #define _GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE #endif #ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_SMALL #define _GLIBCXX_PROFILE_VECTOR_TOO_SMALL #endif #ifndef _GLIBCXX_PROFILE_NO_VECTOR_TOO_LARGE #define _GLIBCXX_PROFILE_VECTOR_TOO_LARGE #endif #ifndef _GLIBCXX_PROFILE_NO_INEFFICIENT_HASH #define _GLIBCXX_PROFILE_INEFFICIENT_HASH #endif #ifndef _GLIBCXX_PROFILE_NO_VECTOR_TO_LIST #define _GLIBCXX_PROFILE_VECTOR_TO_LIST #endif #ifndef _GLIBCXX_PROFILE_NO_LIST_TO_SLIST #define _GLIBCXX_PROFILE_LIST_TO_SLIST #endif #ifndef _GLIBCXX_PROFILE_NO_LIST_TO_VECTOR #define _GLIBCXX_PROFILE_LIST_TO_VECTOR #endif #ifndef _GLIBCXX_PROFILE_NO_MAP_TO_UNORDERED_MAP #define _GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP #endif #endif // Expose global management routines to user code. #ifdef _GLIBCXX_PROFILE #define __profcxx_report() __gnu_profile::__report() #define __profcxx_turn_on() __gnu_profile::__turn_on() #define __profcxx_turn_off() __gnu_profile::__turn_off() #define __profcxx_is_invalid() __gnu_profile::__is_invalid() #define __profcxx_is_on() __gnu_profile::__is_on() #define __profcxx_is_off() __gnu_profile::__is_off() #else #define __profcxx_report() #define __profcxx_turn_on() #define __profcxx_turn_off() #define __profcxx_is_invalid() #define __profcxx_is_on() #define __profcxx_is_off() #endif // Turn on/off instrumentation for HASHTABLE_TOO_SMALL and HASHTABLE_TOO_LARGE. #if (defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_SMALL) \ || defined(_GLIBCXX_PROFILE_HASHTABLE_TOO_LARGE)) #define __profcxx_hashtable_size_construct(__x...) \ __gnu_profile::__trace_hashtable_size_construct(__x) #define __profcxx_hashtable_size_resize(__x...) \ __gnu_profile::__trace_hashtable_size_resize(__x) #define __profcxx_hashtable_size_destruct(__x...) \ __gnu_profile::__trace_hashtable_size_destruct(__x) #else #define __profcxx_hashtable_size_construct(__x...) 0 #define __profcxx_hashtable_size_resize(__x...) #define __profcxx_hashtable_size_destruct(__x...) #endif // Turn on/off instrumentation for VECTOR_TOO_SMALL and VECTOR_TOO_LARGE. #if (defined(_GLIBCXX_PROFILE_VECTOR_TOO_SMALL) \ || defined(_GLIBCXX_PROFILE_VECTOR_TOO_LARGE)) #define __profcxx_vector_size_construct(__x...) \ __gnu_profile::__trace_vector_size_construct(__x) #define __profcxx_vector_size_resize(__x...) \ __gnu_profile::__trace_vector_size_resize(__x) #define __profcxx_vector_size_destruct(__x...) \ __gnu_profile::__trace_vector_size_destruct(__x) #else #define __profcxx_vector_size_construct(__x...) 0 #define __profcxx_vector_size_resize(__x...) #define __profcxx_vector_size_destruct(__x...) #endif // Turn on/off instrumentation for INEFFICIENT_HASH. #if defined(_GLIBCXX_PROFILE_INEFFICIENT_HASH) #define __profcxx_hash_func_construct(__x...) \ __gnu_profile::__trace_hash_func_construct(__x) #define __profcxx_hash_func_destruct(__x...) \ __gnu_profile::__trace_hash_func_destruct(__x) #else #define __profcxx_hash_func_construct(__x...) 0 #define __profcxx_hash_func_destruct(__x...) #endif // Turn on/off instrumentation for VECTOR_TO_LIST. #if defined(_GLIBCXX_PROFILE_VECTOR_TO_LIST) #define __profcxx_vector2list_construct(__x...) \ __gnu_profile::__trace_vector_to_list_construct(__x) #define __profcxx_vector2list_insert(__x...) \ __gnu_profile::__trace_vector_to_list_insert(__x) #define __profcxx_vector2list_iterate(__x...) \ __gnu_profile::__trace_vector_to_list_iterate(__x) #define __profcxx_vector2list_invalid_operator(__x...) \ __gnu_profile::__trace_vector_to_list_invalid_operator(__x) #define __profcxx_vector2list_resize(__x...) \ __gnu_profile::__trace_vector_to_list_resize(__x) #define __profcxx_vector2list_destruct(__x...) \ __gnu_profile::__trace_vector_to_list_destruct(__x) #else #define __profcxx_vector2list_construct(__x...) 0 #define __profcxx_vector2list_insert(__x...) #define __profcxx_vector2list_iterate(__x...) #define __profcxx_vector2list_invalid_operator(__x...) #define __profcxx_vector2list_resize(__x...) #define __profcxx_vector2list_destruct(__x...) #endif // Turn on/off instrumentation for LIST_TO_VECTOR. #if defined(_GLIBCXX_PROFILE_LIST_TO_VECTOR) #define __profcxx_list2vector_construct(__x...) \ __gnu_profile::__trace_list_to_vector_construct(__x) #define __profcxx_list2vector_insert(__x...) \ __gnu_profile::__trace_list_to_vector_insert(__x) #define __profcxx_list2vector_iterate(__x...) \ __gnu_profile::__trace_list_to_vector_iterate(__x) #define __profcxx_list2vector_invalid_operator(__x...) \ __gnu_profile::__trace_list_to_vector_invalid_operator(__x) #define __profcxx_list2vector_destruct(__x...) \ __gnu_profile::__trace_list_to_vector_destruct(__x) #else #define __profcxx_list2vector_construct(__x...) 0 #define __profcxx_list2vector_insert(__x...) #define __profcxx_list2vector_iterate(__x...) #define __profcxx_list2vector_invalid_operator(__x...) #define __profcxx_list2vector_destruct(__x...) #endif // Turn on/off instrumentation for LIST_TO_SLIST. #if defined(_GLIBCXX_PROFILE_LIST_TO_SLIST) #define __profcxx_list2slist_construct(__x...) \ __gnu_profile::__trace_list_to_slist_construct(__x) #define __profcxx_list2slist_rewind(__x...) \ __gnu_profile::__trace_list_to_slist_rewind(__x) #define __profcxx_list2slist_operation(__x...) \ __gnu_profile::__trace_list_to_slist_operation(__x) #define __profcxx_list2slist_destruct(__x...) \ __gnu_profile::__trace_list_to_slist_destruct(__x) #else #define __profcxx_list2slist_construct(__x...) 0 #define __profcxx_list2slist_rewind(__x...) #define __profcxx_list2slist_operation(__x...) #define __profcxx_list2slist_destruct(__x...) #endif // Turn on/off instrumentation for MAP_TO_UNORDERED_MAP. #if defined(_GLIBCXX_PROFILE_MAP_TO_UNORDERED_MAP) #define __profcxx_map2umap_construct(__x...) \ __gnu_profile::__trace_map_to_unordered_map_construct(__x) #define __profcxx_map2umap_insert(__x...) \ __gnu_profile::__trace_map_to_unordered_map_insert(__x) #define __profcxx_map2umap_erase(__x...) \ __gnu_profile::__trace_map_to_unordered_map_erase(__x) #define __profcxx_map2umap_iterate(__x...) \ __gnu_profile::__trace_map_to_unordered_map_iterate(__x) #define __profcxx_map2umap_invalidate(__x...) \ __gnu_profile::__trace_map_to_unordered_map_invalidate(__x) #define __profcxx_map2umap_find(__x...) \ __gnu_profile::__trace_map_to_unordered_map_find(__x) #define __profcxx_map2umap_destruct(__x...) \ __gnu_profile::__trace_map_to_unordered_map_destruct(__x) #else #define __profcxx_map2umap_construct(__x...) 0 #define __profcxx_map2umap_insert(__x...) #define __profcxx_map2umap_erase(__x...) #define __profcxx_map2umap_iterate(__x...) #define __profcxx_map2umap_invalidate(__x...) #define __profcxx_map2umap_find(__x...) #define __profcxx_map2umap_destruct(__x...) #endif // Set default values for compile-time customizable variables. #ifndef _GLIBCXX_PROFILE_TRACE_PATH_ROOT #define _GLIBCXX_PROFILE_TRACE_PATH_ROOT "libstdcxx-profile" #endif #ifndef _GLIBCXX_PROFILE_TRACE_ENV_VAR #define _GLIBCXX_PROFILE_TRACE_ENV_VAR "_GLIBCXX_PROFILE_TRACE_PATH_ROOT" #endif #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR #define _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR \ "_GLIBCXX_PROFILE_MAX_WARN_COUNT" #endif #ifndef _GLIBCXX_PROFILE_MAX_WARN_COUNT #define _GLIBCXX_PROFILE_MAX_WARN_COUNT 10 #endif #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH 32 #endif #ifndef _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR #define _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR \ "_GLIBCXX_PROFILE_MAX_STACK_DEPTH" #endif #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC (1 << 28) #endif #ifndef _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR #define _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR \ "_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC" #endif // Instrumentation hook implementations. #include "profile/impl/profiler_hash_func.h" #include "profile/impl/profiler_hashtable_size.h" #include "profile/impl/profiler_map_to_unordered_map.h" #include "profile/impl/profiler_vector_size.h" #include "profile/impl/profiler_vector_to_list.h" #include "profile/impl/profiler_list_to_slist.h" #include "profile/impl/profiler_list_to_vector.h" #endif // _GLIBCXX_PROFILE_PROFILER_H c++/8/profile/impl/profiler_container_size.h000064400000012433152640040220014751 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_container_size.h * @brief Diagnostics for container sizes. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H 1 #include #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { /** @brief A container size instrumentation line in the object table. */ class __container_size_info : public __object_info_base { public: __container_size_info(__stack_t __stack) : __object_info_base(__stack), _M_init(0), _M_max(0), _M_min(0), _M_total(0), _M_item_min(0), _M_item_max(0), _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0) { } void __write(FILE* __f) const { std::fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total, _M_item_min, _M_item_max, _M_item_total); } float __magnitude() const { return static_cast(_M_cost); } std::string __advice() const { std::stringstream __message; if (_M_init < _M_item_max) __message << "change initial container size from " << _M_init << " to " << _M_item_max; return __message.str(); } void __init(std::size_t __num) { _M_init = __num; _M_max = __num; } void __merge(const __container_size_info& __o) { __object_info_base::__merge(__o); _M_init = std::max(_M_init, __o._M_init); _M_max = std::max(_M_max, __o._M_max); _M_item_max = std::max(_M_item_max, __o._M_item_max); _M_min = std::min(_M_min, __o._M_min); _M_item_min = std::min(_M_item_min, __o._M_item_min); _M_total += __o._M_total; _M_item_total += __o._M_item_total; _M_count += __o._M_count; _M_cost += __o._M_cost; _M_resize += __o._M_resize; } // Call if a container is destructed or cleaned. void __destruct(std::size_t __num, std::size_t __inum) { _M_max = std::max(_M_max, __num); _M_item_max = std::max(_M_item_max, __inum); if (_M_min == 0) { _M_min = __num; _M_item_min = __inum; } else { _M_min = std::min(_M_min, __num); _M_item_min = std::min(_M_item_min, __inum); } _M_total += __num; _M_item_total += __inum; _M_count += 1; } // Estimate the cost of resize/rehash. float __resize_cost(std::size_t __from, std::size_t) { return __from; } // Call if container is resized. void __resize(std::size_t __from, std::size_t __to) { _M_cost += this->__resize_cost(__from, __to); _M_resize += 1; _M_max = std::max(_M_max, __to); } private: std::size_t _M_init; std::size_t _M_max; // range of # buckets std::size_t _M_min; std::size_t _M_total; std::size_t _M_item_min; // range of # items std::size_t _M_item_max; std::size_t _M_item_total; std::size_t _M_count; std::size_t _M_resize; std::size_t _M_cost; }; /** @brief A container size instrumentation line in the stack table. */ class __container_size_stack_info : public __container_size_info { public: __container_size_stack_info(const __container_size_info& __o) : __container_size_info(__o) { } }; /** @brief Container size instrumentation trace producer. */ class __trace_container_size : public __trace_base<__container_size_info, __container_size_stack_info> { public: ~__trace_container_size() { } __trace_container_size() : __trace_base<__container_size_info, __container_size_stack_info>() { }; // Insert a new node at construct with object, callstack and initial size. __container_size_info* __insert(__stack_t __stack, std::size_t __num) { __container_size_info* __ret = __add_object(__stack); if (__ret) __ret->__init(__num); return __ret; } // Call at destruction/clean to set container final size. void __destruct(__container_size_info* __obj_info, std::size_t __num, std::size_t __inum) { __obj_info->__destruct(__num, __inum); __retire_object(__obj_info); } }; } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H */ c++/8/profile/impl/profiler_trace.h000064400000050613152640040220013035 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_trace.h * @brief Data structures to represent profiling traces. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H #define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1 #include // fopen, fclose, fprintf, FILE #include #include // atof, atoi, strtol, getenv, atexit, abort #if __cplusplus >= 201103L #include #define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::unordered_map #else #include #define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map #endif #include #include #include #include #include #include "profile/impl/profiler_algos.h" #include "profile/impl/profiler_state.h" #include "profile/impl/profiler_node.h" namespace __gnu_profile { /** @brief Internal environment. Values can be set one of two ways: 1. In config file "var = value". The default config file path is libstdcxx-profile.conf. 2. By setting process environment variables. For instance, in a Bash shell you can set the unit cost of iterating through a map like this: export __map_iterate_cost_factor=5.0. If a value is set both in the input file and through an environment variable, the environment value takes precedence. */ typedef _GLIBCXX_IMPL_UNORDERED_MAP __env_t; _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env); /** @brief Master lock. */ _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_mutex); /** @brief Representation of a warning. */ struct __warning_data { float __magnitude; __stack_t __context; const char* __warning_id; std::string __warning_message; __warning_data() : __magnitude(0.0), __context(0), __warning_id(0) { } __warning_data(float __m, __stack_t __c, const char* __id, const std::string& __msg) : __magnitude(__m), __context(__c), __warning_id(__id), __warning_message(__msg) { } bool operator<(const __warning_data& __other) const { return __magnitude < __other.__magnitude; } }; typedef std::_GLIBCXX_STD_C::vector<__warning_data> __warning_vector_t; // Defined in profiler_.h. class __trace_hash_func; class __trace_hashtable_size; class __trace_map2umap; class __trace_vector_size; class __trace_vector_to_list; class __trace_list_to_slist; class __trace_list_to_vector; void __trace_vector_size_init(); void __trace_hashtable_size_init(); void __trace_hash_func_init(); void __trace_vector_to_list_init(); void __trace_list_to_slist_init(); void __trace_list_to_vector_init(); void __trace_map_to_unordered_map_init(); void __trace_vector_size_report(FILE*, __warning_vector_t&); void __trace_hashtable_size_report(FILE*, __warning_vector_t&); void __trace_hash_func_report(FILE*, __warning_vector_t&); void __trace_vector_to_list_report(FILE*, __warning_vector_t&); void __trace_list_to_slist_report(FILE*, __warning_vector_t&); void __trace_list_to_vector_report(FILE*, __warning_vector_t&); void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); void __trace_vector_size_free(); void __trace_hashtable_size_free(); void __trace_hash_func_free(); void __trace_vector_to_list_free(); void __trace_list_to_slist_free(); void __trace_list_to_vector_free(); void __trace_map_to_unordered_map_free(); struct __cost_factor { const char* __env_var; float __value; }; typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector; _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, {"__vector_shift_cost_factor", 1.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor, {"__vector_iterate_cost_factor", 1.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor, {"__vector_resize_cost_factor", 1.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor, {"__list_shift_cost_factor", 0.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor, {"__list_iterate_cost_factor", 10.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor, {"__list_resize_cost_factor", 0.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor, {"__map_insert_cost_factor", 1.5}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor, {"__map_erase_cost_factor", 1.5}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor, {"__map_find_cost_factor", 1}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor, {"__map_iterate_cost_factor", 2.3}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor, {"__umap_insert_cost_factor", 12.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor, {"__umap_erase_cost_factor", 12.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor, {"__umap_find_cost_factor", 10.0}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor, {"__umap_iterate_cost_factor", 1.7}); _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0); _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name, _GLIBCXX_PROFILE_TRACE_PATH_ROOT); _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count, _GLIBCXX_PROFILE_MAX_WARN_COUNT); _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth, _GLIBCXX_PROFILE_MAX_STACK_DEPTH); _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem, _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC); inline std::size_t __stack_max_depth() { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); } inline std::size_t __max_mem() { return _GLIBCXX_PROFILE_DATA(_S_max_mem); } /** @brief Base class for all trace producers. */ template class __trace_base { public: // Do not pick the initial size too large, as we don't know which // diagnostics are more active. __trace_base() : __objects_byte_size(0), __stack_table(10000), __stack_table_byte_size(0), __id(0) { } ~__trace_base() { for (typename __stack_table_t::iterator __it = __stack_table.begin(); __it != __stack_table.end(); ++__it) delete __it->first; } __object_info* __add_object(__stack_t __stack); void __retire_object(__object_info* __info); void __write(FILE* __f); void __collect_warnings(__warning_vector_t& __warnings); void __free(); private: __gnu_cxx::__mutex __trace_mutex; typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, __stack_hash, __stack_hash> __stack_table_t; std::size_t __objects_byte_size; __stack_table_t __stack_table; std::size_t __stack_table_byte_size; protected: const char* __id; }; template __object_info* __trace_base<__object_info, __stack_info>:: __add_object(__stack_t __stack) { // If we have no backtrace information no need to collect data. if (!__stack) return 0; __gnu_cxx::__scoped_lock __lock(this->__trace_mutex); if (__max_mem() != 0 && __objects_byte_size >= __max_mem()) { delete __stack; return 0; } __object_info* __ret = new(std::nothrow) __object_info(__stack); if (!__ret) { delete __stack; return 0; } __objects_byte_size += sizeof(__object_info); return __ret; } template void __trace_base<__object_info, __stack_info>:: __retire_object(__object_info* __obj_info) { if (!__obj_info) return; __gnu_cxx::__scoped_lock __lock(this->__trace_mutex); const __object_info& __info = *__obj_info; __stack_t __stack = __info.__stack(); typename __stack_table_t::iterator __stack_it = __stack_table.find(__stack); if (__stack_it == __stack_table.end()) { // First occurrence of this call context. if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) { __stack_table_byte_size += (sizeof(__instruction_address_t) * __size(__stack) + sizeof(__stack) + sizeof(__stack_info)); __stack_table.insert(make_pair(__stack, __stack_info(__info))); } else delete __stack; } else { // Merge object info into info summary for this call context. __stack_it->second.__merge(__info); delete __stack; } delete __obj_info; __objects_byte_size -= sizeof(__object_info); } template void __trace_base<__object_info, __stack_info>:: __write(FILE* __f) { for (typename __stack_table_t::iterator __it = __stack_table.begin(); __it != __stack_table.end(); ++__it) if (__it->second.__is_valid()) { std::fprintf(__f, __id); std::fprintf(__f, "|"); __gnu_profile::__write(__f, __it->first); std::fprintf(__f, "|"); __it->second.__write(__f); } } template void __trace_base<__object_info, __stack_info>:: __collect_warnings(__warning_vector_t& __warnings) { for (typename __stack_table_t::iterator __it = __stack_table.begin(); __it != __stack_table.end(); ++__it) __warnings.push_back(__warning_data(__it->second.__magnitude(), __it->first, __id, __it->second.__advice())); } template inline void __trace_report(__trace_base<__object_info, __stack_info>* __cont, FILE* __f, __warning_vector_t& __warnings) { if (__cont) { __cont->__collect_warnings(__warnings); __cont->__write(__f); } } inline std::size_t __env_to_size_t(const char* __env_var, std::size_t __default_value) { char* __env_value = std::getenv(__env_var); if (__env_value) { errno = 0; long __converted_value = std::strtol(__env_value, 0, 10); if (errno || __converted_value < 0) { std::fprintf(stderr, "Bad value for environment variable '%s'.\n", __env_var); std::abort(); } else return static_cast(__converted_value); } else return __default_value; } inline void __set_max_stack_trace_depth() { _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)); } inline void __set_max_mem() { _GLIBCXX_PROFILE_DATA(_S_max_mem) = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, _GLIBCXX_PROFILE_DATA(_S_max_mem)); } inline int __log_magnitude(float __f) { const float __log_base = 10.0; int __result = 0; int __sign = 1; if (__f < 0) { __f = -__f; __sign = -1; } while (__f > __log_base) { ++__result; __f /= 10.0; } return __sign * __result; } inline FILE* __open_output_file(const char* __extension) { // The path is made of _S_trace_file_name + "." + extension. std::size_t __root_len = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); std::size_t __ext_len = __builtin_strlen(__extension); char* __file_name = new char[__root_len + 1 + __ext_len + 1]; __builtin_memcpy(__file_name, _GLIBCXX_PROFILE_DATA(_S_trace_file_name), __root_len); *(__file_name + __root_len) = '.'; __builtin_memcpy(__file_name + __root_len + 1, __extension, __ext_len + 1); FILE* __out_file = std::fopen(__file_name, "w"); if (!__out_file) { std::fprintf(stderr, "Could not open trace file '%s'.\n", __file_name); std::abort(); } delete[] __file_name; return __out_file; } struct __warn { FILE* __file; __warn(FILE* __f) { __file = __f; } void operator()(const __warning_data& __info) { std::fprintf(__file, __info.__warning_id); std::fprintf(__file, ": improvement = %d", __log_magnitude(__info.__magnitude)); std::fprintf(__file, ": call stack = "); __gnu_profile::__write(__file, __info.__context); std::fprintf(__file, ": advice = %s\n", __info.__warning_message.c_str()); } }; /** @brief Final report method, registered with @b atexit. * * This can also be called directly by user code, including signal handlers. * It is protected against deadlocks by the reentrance guard in profiler.h. * However, when called from a signal handler that triggers while within * __gnu_profile (under the guarded zone), no output will be produced. */ inline void __report() { __gnu_cxx::__scoped_lock __lock(_GLIBCXX_PROFILE_DATA(__global_mutex)); __warning_vector_t __warnings, __top_warnings; FILE* __raw_file = __open_output_file("raw"); __trace_vector_size_report(__raw_file, __warnings); __trace_hashtable_size_report(__raw_file, __warnings); __trace_hash_func_report(__raw_file, __warnings); __trace_vector_to_list_report(__raw_file, __warnings); __trace_list_to_slist_report(__raw_file, __warnings); __trace_list_to_vector_report(__raw_file, __warnings); __trace_map_to_unordered_map_report(__raw_file, __warnings); std::fclose(__raw_file); // Sort data by magnitude, keeping just top N. std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count), __warnings.size()); __top_n(__warnings, __top_warnings, __cutoff); FILE* __warn_file = __open_output_file("txt"); __for_each(__top_warnings.begin(), __top_warnings.end(), __warn(__warn_file)); std::fclose(__warn_file); } inline void __report_and_free() { __report(); __trace_map_to_unordered_map_free(); __trace_list_to_vector_free(); __trace_list_to_slist_free(); __trace_vector_to_list_free(); __trace_hash_func_free(); __trace_hashtable_size_free(); __trace_vector_size_free(); delete _GLIBCXX_PROFILE_DATA(__cost_factors); } inline void __set_trace_path() { char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); if (__env_trace_file_name) _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name; // Make sure early that we can create the trace file. std::fclose(__open_output_file("txt")); } inline void __set_max_warn_count() { char* __env_max_warn_count_str = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); if (__env_max_warn_count_str) _GLIBCXX_PROFILE_DATA(_S_max_warn_count) = static_cast(std::atoi(__env_max_warn_count_str)); } inline void __read_cost_factors() { std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); __conf_file_name += ".conf"; std::ifstream __conf_file(__conf_file_name.c_str()); if (__conf_file.is_open()) { std::string __line; while (std::getline(__conf_file, __line)) { std::string::size_type __i = __line.find_first_not_of(" \t\n\v"); if (__line.length() <= 0 || __line[__i] == '#') // Skip empty lines or comments. continue; } // Trim. __line.erase(__remove(__line.begin(), __line.end(), ' '), __line.end()); std::string::size_type __pos = __line.find("="); std::string __factor_name = __line.substr(0, __pos); std::string::size_type __end = __line.find_first_of(";\n"); std::string __factor_value = __line.substr(__pos + 1, __end - __pos); _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value; } } struct __cost_factor_writer { FILE* __file; __cost_factor_writer(FILE* __f) : __file(__f) { } void operator() (const __cost_factor* __factor) { std::fprintf(__file, "%s = %f\n", __factor->__env_var, __factor->__value); } }; inline void __write_cost_factors() { FILE* __file = __open_output_file("conf.out"); __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), __cost_factor_writer(__file)); std::fclose(__file); } struct __cost_factor_setter { void operator()(__cost_factor* __factor) { // Look it up in the process environment first. const char* __env_value = std::getenv(__factor->__env_var); if (!__env_value) { // Look it up in the config file. __env_t::iterator __it = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var); if (__it != _GLIBCXX_PROFILE_DATA(__env).end()) __env_value = __it->second.c_str(); } if (__env_value) __factor->__value = std::atof(__env_value); } }; inline void __set_cost_factors() { __cost_factor_vector* __factors = new __cost_factor_vector; _GLIBCXX_PROFILE_DATA(__cost_factors) = __factors; __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor)); __factors->push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor)); __for_each(__factors->begin(), __factors->end(), __cost_factor_setter()); } inline void __profcxx_init_unconditional() { __gnu_cxx::__scoped_lock __lock(_GLIBCXX_PROFILE_DATA(__global_mutex)); if (__is_invalid()) { __set_max_warn_count(); if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) __turn_off(); else { __set_max_stack_trace_depth(); __set_max_mem(); __set_trace_path(); __read_cost_factors(); __set_cost_factors(); __write_cost_factors(); __trace_vector_size_init(); __trace_hashtable_size_init(); __trace_hash_func_init(); __trace_vector_to_list_init(); __trace_list_to_slist_init(); __trace_list_to_vector_init(); __trace_map_to_unordered_map_init(); std::atexit(__report_and_free); __turn_on(); } } } /** @brief This function must be called by each instrumentation point. * * The common path is inlined fully. */ inline bool __profcxx_init() { if (__is_invalid()) __profcxx_init_unconditional(); return __is_on(); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */ c++/8/profile/impl/profiler_map_to_unordered_map.h000064400000015651152640040220016125 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_map_to_unordered_map.h * @brief Diagnostics for map to unordered_map. */ // Written by Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H #define _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { inline int __log2(std::size_t __size) { for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0; -- __bit_count) if ((2 << __bit_count) & __size) return __bit_count; return 0; } inline float __map_insert_cost(std::size_t __size) { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value * static_cast(__log2(__size))); } inline float __map_erase_cost(std::size_t __size) { return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value * static_cast(__log2(__size))); } inline float __map_find_cost(std::size_t __size) { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value * static_cast(__log2(__size))); } /** @brief A map-to-unordered_map instrumentation line in the object table. */ class __map2umap_info : public __object_info_base { public: __map2umap_info(__stack_t __stack) : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0) { } void __merge(const __map2umap_info& __o) { __object_info_base::__merge(__o); _M_insert += __o._M_insert; _M_erase += __o._M_erase; _M_find += __o._M_find; _M_iterate += __o._M_iterate; _M_umap_cost += __o._M_umap_cost; _M_map_cost += __o._M_map_cost; } void __write(FILE* __f) const { std::fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f\n", _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, _M_umap_cost); } float __magnitude() const { return _M_map_cost - _M_umap_cost; } std::string __advice() const { return "prefer an unordered container"; } void __record_insert(std::size_t __size, std::size_t __count) { ++_M_insert; if (__count) { _M_map_cost += __count * __map_insert_cost(__size); _M_umap_cost += (__count * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value); } } void __record_erase(std::size_t __size, std::size_t __count) { ++_M_erase; if (__count) { _M_map_cost += __count * __map_erase_cost(__size); _M_umap_cost += (__count * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value); } } void __record_find(std::size_t __size) { ++_M_find; _M_map_cost += __map_find_cost(__size); _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value; } void __record_iterate(int __count) { __gnu_cxx::__atomic_add(&_M_iterate, __count); } void __set_iterate_costs() { _M_umap_cost += (_M_iterate * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value); _M_map_cost += (_M_iterate * _GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor).__value); } private: std::size_t _M_insert; std::size_t _M_erase; std::size_t _M_find; mutable _Atomic_word _M_iterate; float _M_umap_cost; float _M_map_cost; }; /** @brief A map-to-unordered_map instrumentation line in the stack table. */ class __map2umap_stack_info : public __map2umap_info { public: __map2umap_stack_info(const __map2umap_info& __o) : __map2umap_info(__o) { } }; /** @brief Map-to-unordered_map instrumentation producer. */ class __trace_map2umap : public __trace_base<__map2umap_info, __map2umap_stack_info> { public: __trace_map2umap() : __trace_base<__map2umap_info, __map2umap_stack_info>() { __id = "ordered-to-unordered"; } // Call at destruction/clean to set container final size. void __destruct(__map2umap_info* __obj_info) { __obj_info->__set_iterate_costs(); __retire_object(__obj_info); } }; inline void __trace_map_to_unordered_map_init() { _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); } inline void __trace_map_to_unordered_map_free() { delete _GLIBCXX_PROFILE_DATA(_S_map2umap); } inline void __trace_map_to_unordered_map_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_map2umap), __f, __warnings); } inline __map2umap_info* __trace_map_to_unordered_map_construct() { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_map2umap)->__add_object(__get_stack()); } inline void __trace_map_to_unordered_map_insert(__map2umap_info* __info, std::size_t __size, std::size_t __count) { if (!__info) return; __info->__record_insert(__size, __count); } inline void __trace_map_to_unordered_map_erase(__map2umap_info* __info, std::size_t __size, std::size_t __count) { if (!__info) return; __info->__record_erase(__size, __count); } inline void __trace_map_to_unordered_map_find(__map2umap_info* __info, std::size_t __size) { if (!__info) return; __info->__record_find(__size); } inline void __trace_map_to_unordered_map_iterate(__map2umap_info* __info, int) { if (!__info) return; // We only collect if an iteration took place no matter in what side. __info->__record_iterate(1); } inline void __trace_map_to_unordered_map_invalidate(__map2umap_info* __info) { if (!__info) return; __info->__set_invalid(); } inline void __trace_map_to_unordered_map_destruct(__map2umap_info* __info) { if (!__info) return; _GLIBCXX_PROFILE_DATA(_S_map2umap)->__destruct(__info); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H */ c++/8/profile/impl/profiler_hash_func.h000064400000010474152640040220013676 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_hash_func.h * @brief Data structures to represent profiling traces. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H #define _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { /** @brief A hash performance instrumentation line in the object table. */ class __hashfunc_info : public __object_info_base { public: __hashfunc_info(__stack_t __stack) : __object_info_base(__stack), _M_longest_chain(0), _M_accesses(0), _M_hops(0) { } void __merge(const __hashfunc_info& __o) { __object_info_base::__merge(__o); _M_longest_chain = std::max(_M_longest_chain, __o._M_longest_chain); _M_accesses += __o._M_accesses; _M_hops += __o._M_hops; } void __destruct(std::size_t __chain, std::size_t __accesses, std::size_t __hops) { _M_longest_chain = std::max(_M_longest_chain, __chain); _M_accesses += __accesses; _M_hops += __hops; } void __write(FILE* __f) const { std::fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain); } float __magnitude() const { return static_cast(_M_hops); } std::string __advice() const { return "change hash function"; } private: std::size_t _M_longest_chain; std::size_t _M_accesses; std::size_t _M_hops; }; /** @brief A hash performance instrumentation line in the stack table. */ class __hashfunc_stack_info : public __hashfunc_info { public: __hashfunc_stack_info(const __hashfunc_info& __o) : __hashfunc_info(__o) { } }; /** @brief Hash performance instrumentation producer. */ class __trace_hash_func : public __trace_base<__hashfunc_info, __hashfunc_stack_info> { public: __trace_hash_func() : __trace_base<__hashfunc_info, __hashfunc_stack_info>() { __id = "hash-distr"; } ~__trace_hash_func() {} // Call at destruction/clean to set container final size. void __destruct(__hashfunc_info* __obj_info, std::size_t __chain, std::size_t __accesses, std::size_t __hops) { if (!__obj_info) return; __obj_info->__destruct(__chain, __accesses, __hops); __retire_object(__obj_info); } }; inline void __trace_hash_func_init() { _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); } inline void __trace_hash_func_free() { delete _GLIBCXX_PROFILE_DATA(_S_hash_func); } inline void __trace_hash_func_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_hash_func), __f, __warnings); } inline __hashfunc_info* __trace_hash_func_construct() { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_hash_func)->__add_object(__get_stack()); } inline void __trace_hash_func_destruct(__hashfunc_info* __obj_info, std::size_t __chain, std::size_t __accesses, std::size_t __hops) { _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj_info, __chain, __accesses, __hops); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H */ c++/8/profile/impl/profiler_vector_size.h000064400000005560152640040220014274 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_vector_size.h * @brief Collection of vector size traces. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" #include "profile/impl/profiler_state.h" #include "profile/impl/profiler_container_size.h" namespace __gnu_profile { /** @brief Hashtable size instrumentation trace producer. */ class __trace_vector_size : public __trace_container_size { public: __trace_vector_size() : __trace_container_size() { __id = "vector-size"; } }; inline void __trace_vector_size_init() { _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); } inline void __trace_vector_size_free() { delete _GLIBCXX_PROFILE_DATA(_S_vector_size); } inline void __trace_vector_size_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_vector_size), __f, __warnings); } inline __container_size_info* __trace_vector_size_construct(std::size_t __num) { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_vector_size)-> __insert(__get_stack(), __num); } inline void __trace_vector_size_resize(__container_size_info* __obj_info, std::size_t __from, std::size_t __to) { if (!__obj_info) return; __obj_info->__resize(__from, __to); } inline void __trace_vector_size_destruct(__container_size_info* __obj_info, std::size_t __num, std::size_t __inum) { if (!__obj_info) return; _GLIBCXX_PROFILE_DATA(_S_vector_size)-> __destruct(__obj_info, __num, __inum); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H */ c++/8/profile/impl/profiler_hashtable_size.h000064400000005646152640040220014732 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_hashtable_size.h * @brief Collection of hashtable size traces. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" #include "profile/impl/profiler_state.h" #include "profile/impl/profiler_container_size.h" namespace __gnu_profile { /** @brief Hashtable size instrumentation trace producer. */ class __trace_hashtable_size : public __trace_container_size { public: __trace_hashtable_size() : __trace_container_size() { __id = "hashtable-size"; } }; inline void __trace_hashtable_size_init() { _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); } inline void __trace_hashtable_size_free() { delete _GLIBCXX_PROFILE_DATA(_S_hashtable_size); } inline void __trace_hashtable_size_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_hashtable_size), __f, __warnings); } inline __container_size_info* __trace_hashtable_size_construct(std::size_t __num) { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_hashtable_size)-> __insert(__get_stack(), __num); } inline void __trace_hashtable_size_resize(__container_size_info* __obj_info, std::size_t __from, std::size_t __to) { if (!__obj_info) return; __obj_info->__resize(__from, __to); } inline void __trace_hashtable_size_destruct(__container_size_info* __obj_info, std::size_t __num, std::size_t __inum) { if (!__obj_info) return; _GLIBCXX_PROFILE_DATA(_S_hashtable_size)-> __destruct(__obj_info, __num, __inum); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H */ c++/8/profile/impl/profiler_list_to_slist.h000064400000010526152640040220014631 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_list_to_slist.h * @brief Diagnostics for list to slist. */ // Written by Changhee Jung. #ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H #define _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { class __list2slist_info : public __object_info_base { public: __list2slist_info(__stack_t __stack) : __object_info_base(__stack), _M_rewind(false), _M_operations(0) { } // XXX: the magnitude should be multiplied with a constant factor F, // where F is 1 when the malloc size class of list nodes is different // from the malloc size class of slist nodes. When they fall into the same // class, the only slist benefit is from having to set fewer links, so // the factor F should be much smaller, closer to 0 than to 1. // This could be implemented by passing the size classes in the config // file. For now, we always assume F to be 1. float __magnitude() const { if (!_M_rewind) return _M_operations; else return 0; } void __write(FILE* __f) const { std::fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); } std::string __advice() const { return "change std::list to std::forward_list"; } void __opr_rewind() { _M_rewind = true; __set_invalid(); } void __record_operation() { ++_M_operations; } bool __has_rewind() { return _M_rewind; } private: bool _M_rewind; std::size_t _M_operations; }; class __list2slist_stack_info : public __list2slist_info { public: __list2slist_stack_info(const __list2slist_info& __o) : __list2slist_info(__o) { } }; class __trace_list_to_slist : public __trace_base<__list2slist_info, __list2slist_stack_info> { public: ~__trace_list_to_slist() { } __trace_list_to_slist() : __trace_base<__list2slist_info, __list2slist_stack_info>() { __id = "list-to-slist"; } void __destruct(__list2slist_info* __obj_info) { __retire_object(__obj_info); } }; inline void __trace_list_to_slist_init() { _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); } inline void __trace_list_to_slist_free() { delete _GLIBCXX_PROFILE_DATA(_S_list_to_slist); } inline void __trace_list_to_slist_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_list_to_slist), __f, __warnings); } inline __list2slist_info* __trace_list_to_slist_construct() { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__add_object(__get_stack()); } inline void __trace_list_to_slist_rewind(__list2slist_info* __obj_info) { if (!__obj_info) return; __obj_info->__opr_rewind(); } inline void __trace_list_to_slist_operation(__list2slist_info* __obj_info) { if (!__obj_info) return; __obj_info->__record_operation(); } inline void __trace_list_to_slist_destruct(__list2slist_info* __obj_info) { if (!__obj_info) return; _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj_info); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H */ c++/8/profile/impl/profiler_vector_to_list.h000064400000015335152640040220015000 0ustar00// -*- C++ -*- // // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_vector_to_list.h * @brief diagnostics for vector to list. */ // Written by Lixia Liu and Silvius Rus. #ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H #define _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H 1 #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { /** @brief A vector-to-list instrumentation line in the object table. */ class __vector2list_info : public __object_info_base { public: __vector2list_info(__stack_t __stack) : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), _M_vector_cost(0) { } void __merge(const __vector2list_info& __o) { __object_info_base::__merge(__o); _M_shift_count += __o._M_shift_count; _M_iterate += __o._M_iterate; _M_vector_cost += __o._M_vector_cost; _M_list_cost += __o._M_list_cost; _M_resize += __o._M_resize; } void __write(FILE* __f) const { std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); } float __magnitude() const { return _M_vector_cost - _M_list_cost; } std::string __advice() const { return "change std::vector to std::list"; } std::size_t __shift_count() { return _M_shift_count; } std::size_t __iterate() { return _M_iterate; } float __list_cost() { return _M_list_cost; } std::size_t __resize() { return _M_resize; } void __set_list_cost(float __lc) { _M_list_cost = __lc; } void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } void __opr_insert(std::size_t __pos, std::size_t __num) { _M_shift_count += __num - __pos; } void __opr_iterate(int __num) { __gnu_cxx::__atomic_add(&_M_iterate, __num); } void __resize(std::size_t __from, std::size_t) { _M_resize += __from; } private: std::size_t _M_shift_count; mutable _Atomic_word _M_iterate; std::size_t _M_resize; float _M_list_cost; float _M_vector_cost; }; /** @brief A vector-to-list instrumentation line in the stack table. */ class __vector2list_stack_info : public __vector2list_info { public: __vector2list_stack_info(const __vector2list_info& __o) : __vector2list_info(__o) { } }; /** @brief Vector-to-list instrumentation producer. */ class __trace_vector_to_list : public __trace_base<__vector2list_info, __vector2list_stack_info> { public: __trace_vector_to_list() : __trace_base<__vector2list_info, __vector2list_stack_info>() { __id = "vector-to-list"; } ~__trace_vector_to_list() { } // Call at destruction/clean to set container final size. void __destruct(__vector2list_info* __obj_info) { float __vc = __vector_cost(__obj_info->__shift_count(), __obj_info->__iterate(), __obj_info->__resize()); float __lc = __list_cost(__obj_info->__shift_count(), __obj_info->__iterate(), __obj_info->__resize()); __obj_info->__set_vector_cost(__vc); __obj_info->__set_list_cost(__lc); __retire_object(__obj_info); } // Collect cost of operations. float __vector_cost(std::size_t __shift, std::size_t __iterate, std::size_t __resize) { return (__shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value + __resize * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value); } float __list_cost(std::size_t __shift, std::size_t __iterate, std::size_t __resize) { return (__shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value + __resize * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value); } }; inline void __trace_vector_to_list_init() { _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); } inline void __trace_vector_to_list_free() { delete _GLIBCXX_PROFILE_DATA(_S_vector_to_list); } inline void __trace_vector_to_list_report(FILE* __f, __warning_vector_t& __warnings) { __trace_report(_GLIBCXX_PROFILE_DATA(_S_vector_to_list), __f, __warnings); } inline __vector2list_info* __trace_vector_to_list_construct() { if (!__profcxx_init()) return 0; if (!__reentrance_guard::__get_in()) return 0; __reentrance_guard __get_out; return _GLIBCXX_PROFILE_DATA(_S_vector_to_list) ->__add_object(__get_stack()); } inline void __trace_vector_to_list_insert(__vector2list_info* __obj_info, std::size_t __pos, std::size_t __num) { if (!__obj_info) return; __obj_info->__opr_insert(__pos, __num); } inline void __trace_vector_to_list_iterate(__vector2list_info* __obj_info, int) { if (!__obj_info) return; // We only collect if an iteration took place no matter in what side. __obj_info->__opr_iterate(1); } inline void __trace_vector_to_list_invalid_operator(__vector2list_info* __obj_info) { if (!__obj_info) return; __obj_info->__set_invalid(); } inline void __trace_vector_to_list_resize(__vector2list_info* __obj_info, std::size_t __from, std::size_t __to) { if (!__obj_info) return; __obj_info->__resize(__from, __to); } inline void __trace_vector_to_list_destruct(__vector2list_info* __obj_info) { if (!__obj_info) return; _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj_info); } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H */ c++/8/profile/impl/profiler_algos.h000064400000006545152640040220013051 0ustar00// -*- C++ -*- // // Copyright (C) 2010-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/impl/profiler_algos.h * @brief Algorithms used by the profile extension. * * This file is needed to avoid including \ or \. * Including those files would result in recursive includes. * These implementations are oversimplified. In general, efficiency may be * sacrificed to minimize maintenance overhead. */ #ifndef _GLIBCXX_PROFILE_PROFILER_ALGOS_H #define _GLIBCXX_PROFILE_PROFILER_ALGOS_H 1 namespace __gnu_profile { /* Helper for __top_n. Insert in sorted vector, but not beyond Nth elem. */ template void __insert_top_n(_Container& __output, const typename _Container::value_type& __value, typename _Container::size_type __n) { typename _Container::iterator __it = __output.begin(); typename _Container::size_type __count = 0; // Skip up to N - 1 elements larger than VALUE. // XXX: Could do binary search for random iterators. while (true) { if (__count >= __n) // VALUE is not in top N. return; if (__it == __output.end()) break; if (*__it < __value) break; ++__it; ++__count; } __output.insert(__it, __value); } /* Copy the top N elements in INPUT, sorted in reverse order, to OUTPUT. */ template void __top_n(const _Container& __input, _Container& __output, typename _Container::size_type __n) { __output.clear(); typename _Container::const_iterator __it; for (__it = __input.begin(); __it != __input.end(); ++__it) __insert_top_n(__output, *__it, __n); } /* Simplified clone of std::for_each. */ template _Function __for_each(_InputIterator __first, _InputIterator __last, _Function __f) { for (; __first != __last; ++__first) __f(*__first); return __f; } /* Simplified clone of std::remove. */ template _ForwardIterator __remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { if(__first == __last) return __first; _ForwardIterator __result = __first; ++__first; for(; __first != __last; ++__first) if(!(*__first == __value)) { *__result = *__first; ++__result; } return __result; } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_ALGOS_H */ c++/8/profile/deque000064400000012231152640040220007743 0ustar00// Profiling deque implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/deque * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_DEQUE #define _GLIBCXX_PROFILE_DEQUE 1 #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::deque wrapper with performance instrumentation. template > class deque : public _GLIBCXX_STD_C::deque<_Tp, _Allocator> { typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::value_type value_type; // 23.2.1.1 construct/copy/destroy: #if __cplusplus < 201103L deque() : _Base() { } deque(const deque& __x) : _Base(__x) { } ~deque() { } #else deque() = default; deque(const deque&) = default; deque(deque&&) = default; deque(const deque& __d, const _Allocator& __a) : _Base(__d, __a) { } deque(deque&& __d, const _Allocator& __a) : _Base(std::move(__d), __a) { } ~deque() = default; deque(initializer_list __l, const _Allocator& __a = _Allocator()) : _Base(__l, __a) { } #endif explicit deque(const _Allocator& __a) : _Base(__a) { } #if __cplusplus >= 201103L explicit deque(size_type __n, const _Allocator& __a = _Allocator()) : _Base(__n, __a) { } deque(size_type __n, const _Tp& __value, const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #else explicit deque(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #endif #if __cplusplus >= 201103L template> #else template #endif deque(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) : _Base(__first, __last, __a) { } deque(const _Base& __x) : _Base(__x) { } #if __cplusplus < 201103L deque& operator=(const deque& __x) { _M_base() = __x; return *this; } #else deque& operator=(const deque&) = default; deque& operator=(deque&&) = default; deque& operator=(initializer_list __l) { _M_base() = __l; return *this; } #endif void swap(deque& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { _Base::swap(__x); } _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } }; template inline bool operator==(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() == __rhs._M_base(); } template inline bool operator!=(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() != __rhs._M_base(); } template inline bool operator<(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() < __rhs._M_base(); } template inline bool operator<=(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() <= __rhs._M_base(); } template inline bool operator>=(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() >= __rhs._M_base(); } template inline bool operator>(const deque<_Tp, _Alloc>& __lhs, const deque<_Tp, _Alloc>& __rhs) { return __lhs._M_base() > __rhs._M_base(); } template inline void swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs) _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } } // namespace __profile } // namespace std #endif c++/8/profile/unordered_map000064400000042210152640040220011464 0ustar00// Profiling unordered_map/unordered_multimap implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/unordered_map * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_UNORDERED_MAP #define _GLIBCXX_PROFILE_UNORDERED_MAP 1 #if __cplusplus < 201103L # include #else # include #include #include #define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc> #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::unordered_map wrapper with performance instrumentation. template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator > > class unordered_map : public _GLIBCXX_STD_BASE, public _Unordered_profile, true> { typedef typename _GLIBCXX_STD_BASE _Base; _Base& _M_base() noexcept { return *this; } const _Base& _M_base() const noexcept { return *this; } public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; typedef typename _Base::key_type key_type; typedef typename _Base::value_type value_type; typedef typename _Base::difference_type difference_type; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef typename _Base::mapped_type mapped_type; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; unordered_map() = default; explicit unordered_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_map(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_map(const unordered_map&) = default; unordered_map(const _Base& __x) : _Base(__x) { } unordered_map(unordered_map&&) = default; explicit unordered_map(const allocator_type& __a) : _Base(__a) { } unordered_map(const unordered_map& __umap, const allocator_type& __a) : _Base(__umap, __a) { } unordered_map(unordered_map&& __umap, const allocator_type& __a) : _Base(std::move(__umap._M_base()), __a) { } unordered_map(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__l, __n, __hf, __eql, __a) { } unordered_map(size_type __n, const allocator_type& __a) : unordered_map(__n, hasher(), key_equal(), __a) { } unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__n, __hf, key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__first, __last, __n, __hf, key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_map(__l, __n, hasher(), key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__l, __n, __hf, key_equal(), __a) { } unordered_map& operator=(const unordered_map&) = default; unordered_map& operator=(unordered_map&&) = default; unordered_map& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } void clear() noexcept { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } template std::pair emplace(_Args&&... __args) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::emplace(std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } template iterator emplace_hint(const_iterator __it, _Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace_hint(__it, std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } void insert(std::initializer_list __l) { size_type __old_size = _Base::bucket_count(); _Base::insert(__l); this->_M_profile_resize(__old_size); } std::pair insert(const value_type& __obj) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::insert(__obj); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, const value_type& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, __v); this->_M_profile_resize(__old_size); return __res; } template::value>::type> std::pair insert(_Pair&& __obj) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::insert(std::forward<_Pair>(__obj)); this->_M_profile_resize(__old_size); return __res; } template::value>::type> iterator insert(const_iterator __iter, _Pair&& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v)); this->_M_profile_resize(__old_size); return __res; } template void insert(_InputIter __first, _InputIter __last) { size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); this->_M_profile_resize(__old_size); } // operator[] mapped_type& operator[](const _Key& __k) { size_type __old_size = _Base::bucket_count(); mapped_type& __res = _M_base()[__k]; this->_M_profile_resize(__old_size); return __res; } mapped_type& operator[](_Key&& __k) { size_type __old_size = _Base::bucket_count(); mapped_type& __res = _M_base()[std::move(__k)]; this->_M_profile_resize(__old_size); return __res; } void swap(unordered_map& __x) noexcept( noexcept(__x._M_base().swap(__x)) ) { _Base::swap(__x._M_base()); this->_M_swap(__x); } void rehash(size_type __n) { size_type __old_size = _Base::bucket_count(); _Base::rehash(__n); this->_M_profile_resize(__old_size); } }; template inline void swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return static_cast(__x) == __y; } template inline bool operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } #undef _GLIBCXX_BASE #undef _GLIBCXX_STD_BASE #define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc> #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE /// Class std::unordered_multimap wrapper with performance instrumentation. template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator > > class unordered_multimap : public _GLIBCXX_STD_BASE, public _Unordered_profile, false> { typedef typename _GLIBCXX_STD_BASE _Base; _Base& _M_base() noexcept { return *this; } const _Base& _M_base() const noexcept { return *this; } public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; typedef typename _Base::key_type key_type; typedef typename _Base::value_type value_type; typedef typename _Base::difference_type difference_type; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; unordered_multimap() = default; explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_multimap(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_multimap(const unordered_multimap&) = default; unordered_multimap(const _Base& __x) : _Base(__x) { } unordered_multimap(unordered_multimap&&) = default; explicit unordered_multimap(const allocator_type& __a) : _Base(__a) { } unordered_multimap(const unordered_multimap& __ummap, const allocator_type& __a) : _Base(__ummap._M_base(), __a) { } unordered_multimap(unordered_multimap&& __ummap, const allocator_type& __a) : _Base(std::move(__ummap._M_base()), __a) { } unordered_multimap(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__l, __n, __hf, __eql, __a) { } unordered_multimap(size_type __n, const allocator_type& __a) : unordered_multimap(__n, hasher(), key_equal(), __a) { } unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__n, __hf, key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_multimap(__l, __n, hasher(), key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__l, __n, __hf, key_equal(), __a) { } unordered_multimap& operator=(const unordered_multimap&) = default; unordered_multimap& operator=(unordered_multimap&&) = default; unordered_multimap& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } void clear() noexcept { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } template iterator emplace(_Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace(std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } template iterator emplace_hint(const_iterator __it, _Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace_hint(__it, std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } void insert(std::initializer_list __l) { size_type __old_size = _Base::bucket_count(); _Base::insert(__l); this->_M_profile_resize(__old_size); } iterator insert(const value_type& __obj) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__obj); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, const value_type& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, __v); this->_M_profile_resize(__old_size); return __res; } template::value>::type> iterator insert(_Pair&& __obj) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(std::forward<_Pair>(__obj)); this->_M_profile_resize(__old_size); return __res; } template::value>::type> iterator insert(const_iterator __iter, _Pair&& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v)); this->_M_profile_resize(__old_size); return __res; } template void insert(_InputIter __first, _InputIter __last) { size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); this->_M_profile_resize(__old_size); } void swap(unordered_multimap& __x) noexcept( noexcept(__x._M_base().swap(__x)) ) { _Base::swap(__x._M_base()); this->_M_swap(__x); } void rehash(size_type __n) { size_type __old_size = _Base::bucket_count(); _Base::rehash(__n); this->_M_profile_resize(__old_size); } }; template inline void swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return static_cast(__x) == __y; } template inline bool operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } } // namespace __profile } // namespace std #undef _GLIBCXX_BASE #undef _GLIBCXX_STD_BASE #endif // C++11 #endif c++/8/profile/list000064400000040736152640040220007626 0ustar00// Profiling list implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/list * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_LIST #define _GLIBCXX_PROFILE_LIST 1 #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template class _List_profile { _List& _M_conjure() { return *static_cast<_List*>(this); } public: __gnu_profile::__list2slist_info* _M_list2slist_info; __gnu_profile::__list2vector_info* _M_list2vector_info; _List_profile() _GLIBCXX_NOEXCEPT { _M_profile_construct(); } void _M_profile_construct() _GLIBCXX_NOEXCEPT { _M_list2slist_info = __profcxx_list2slist_construct(); _M_list2vector_info = __profcxx_list2vector_construct(); } void _M_profile_destruct() _GLIBCXX_NOEXCEPT { __profcxx_list2vector_destruct(_M_list2vector_info); _M_list2vector_info = 0; __profcxx_list2slist_destruct(_M_list2slist_info); _M_list2slist_info = 0; } void _M_swap(_List_profile& __other) { std::swap(_M_list2slist_info, __other._M_list2slist_info); std::swap(_M_list2vector_info, __other._M_list2vector_info); } #if __cplusplus >= 201103L _List_profile(const _List_profile&) noexcept : _List_profile() { } _List_profile(_List_profile&& __other) noexcept : _List_profile() { _M_swap(__other); } _List_profile& operator=(const _List_profile&) noexcept { _M_profile_destruct(); _M_profile_construct(); } _List_profile& operator=(_List_profile&& __other) noexcept { _M_swap(__other); __other._M_profile_destruct(); __other._M_profile_construct(); } #endif ~_List_profile() { _M_profile_destruct(); } }; /** @brief List wrapper with performance instrumentation. */ template > class list : public _GLIBCXX_STD_C::list<_Tp, _Allocator>, public _List_profile > { typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base; public: typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker iterator; typedef __iterator_tracker const_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; typedef _Tp value_type; typedef _Allocator allocator_type; typedef typename _Base::pointer pointer; typedef typename _Base::const_pointer const_pointer; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; // 23.2.2.1 construct/copy/destroy: #if __cplusplus < 201103L list() { } list(const list& __x) : _Base(__x) { } ~list() { } #else list() = default; list(const list&) = default; list(list&&) = default; ~list() = default; list(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__l, __a) { } list(const list& __x, const allocator_type& __a) : _Base(__x, __a) { } list(list&& __x, const allocator_type& __a) : _Base(std::move(__x), __a) { } #endif explicit list(const _Allocator& __a) _GLIBCXX_NOEXCEPT : _Base(__a) { } #if __cplusplus >= 201103L explicit list(size_type __n, const allocator_type& __a = allocator_type()) : _Base(__n, __a) { } list(size_type __n, const _Tp& __value, const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #else explicit list(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #endif #if __cplusplus >= 201103L template> #else template #endif list(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) : _Base(__first, __last, __a) { } list(const _Base& __x) : _Base(__x) { } #if __cplusplus < 201103L list& operator=(const list& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else list& operator=(const list&) = default; list& operator=(list&&) = default; list& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators: iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return const_iterator(_Base::end(), this); } reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::cend(), this); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } #endif // 23.2.2.2 capacity: reference back() _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return _Base::back(); } const_reference back() const _GLIBCXX_NOEXCEPT { __profcxx_list2slist_rewind(this->_M_list2slist_info); return _Base::back(); } // 23.2.2.3 modifiers: void push_front(const value_type& __x) { __profcxx_list2vector_invalid_operator(this->_M_list2vector_info); __profcxx_list2slist_operation(this->_M_list2slist_info); _Base::push_front(__x); } void pop_front() _GLIBCXX_NOEXCEPT { __profcxx_list2slist_operation(this->_M_list2slist_info); _Base::pop_front(); } void pop_back() _GLIBCXX_NOEXCEPT { _Base::pop_back(); __profcxx_list2slist_rewind(this->_M_list2slist_info); } #if __cplusplus >= 201103L template iterator emplace(const_iterator __position, _Args&&... __args) { return iterator(_Base::emplace(__position.base(), std::forward<_Args>(__args)...), this); } #endif iterator #if __cplusplus >= 201103L insert(const_iterator __pos, const _Tp& __x) #else insert(iterator __pos, const _Tp& __x) #endif { _M_profile_insert(__pos, this->size()); return iterator(_Base::insert(__pos.base(), __x), this); } #if __cplusplus >= 201103L iterator insert(const_iterator __pos, _Tp&& __x) { _M_profile_insert(__pos, this->size()); return iterator(_Base::emplace(__pos.base(), std::move(__x)), this); } iterator insert(const_iterator __pos, initializer_list __l) { _M_profile_insert(__pos, this->size()); return iterator(_Base::insert(__pos.base(), __l), this); } #endif #if __cplusplus >= 201103L iterator insert(const_iterator __pos, size_type __n, const _Tp& __x) { _M_profile_insert(__pos, this->size()); return iterator(_Base::insert(__pos.base(), __n, __x), this); } #else void insert(iterator __pos, size_type __n, const _Tp& __x) { _M_profile_insert(__pos, this->size()); _Base::insert(__pos.base(), __n, __x); } #endif #if __cplusplus >= 201103L template> iterator insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) { _M_profile_insert(__pos, this->size()); return iterator(_Base::insert(__pos.base(), __first, __last), this); } #else template void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { _M_profile_insert(__pos, this->size()); _Base::insert(__pos.base(), __first, __last); } #endif iterator #if __cplusplus >= 201103L erase(const_iterator __pos) noexcept #else erase(iterator __pos) #endif { return iterator(_Base::erase(__pos.base()), this); } iterator #if __cplusplus >= 201103L erase(const_iterator __pos, const_iterator __last) noexcept #else erase(iterator __pos, iterator __last) #endif { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 151. can't currently clear() empty container return iterator(_Base::erase(__pos.base(), __last.base()), this); } void swap(list& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } // 23.2.2.4 list operations: void #if __cplusplus >= 201103L splice(const_iterator __pos, list&& __x) noexcept #else splice(iterator __pos, list& __x) #endif { this->splice(__pos, _GLIBCXX_MOVE(__x), __x.begin(), __x.end()); } #if __cplusplus >= 201103L void splice(const_iterator __pos, list& __x) noexcept { this->splice(__pos, std::move(__x)); } void splice(const_iterator __pos, list& __x, const_iterator __i) { this->splice(__pos, std::move(__x), __i); } #endif void #if __cplusplus >= 201103L splice(const_iterator __pos, list&& __x, const_iterator __i) noexcept #else splice(iterator __pos, list& __x, iterator __i) #endif { // We used to perform the splice_alloc check: not anymore, redundant // after implementing the relevant bits of N1599. // _GLIBCXX_RESOLVE_LIB_DEFECTS _Base::splice(__pos.base(), _GLIBCXX_MOVE(__x._M_base()), __i.base()); } void #if __cplusplus >= 201103L splice(const_iterator __pos, list&& __x, const_iterator __first, const_iterator __last) noexcept #else splice(iterator __pos, list& __x, iterator __first, iterator __last) #endif { _Base::splice(__pos.base(), _GLIBCXX_MOVE(__x._M_base()), __first.base(), __last.base()); } #if __cplusplus >= 201103L void splice(const_iterator __pos, list& __x, const_iterator __first, const_iterator __last) noexcept { this->splice(__pos, std::move(__x), __first, __last); } #endif void remove(const _Tp& __value) { for (iterator __x = begin(); __x != end(); ) { if (*__x == __value) __x = erase(__x); else ++__x; } } template void remove_if(_Predicate __pred) { for (iterator __x = begin(); __x != end(); ) { __profcxx_list2slist_operation(this->_M_list2slist_info); if (__pred(*__x)) __x = erase(__x); else ++__x; } } void unique() { iterator __first = begin(); iterator __last = end(); if (__first == __last) return; iterator __next = __first; while (++__next != __last) { __profcxx_list2slist_operation(this->_M_list2slist_info); if (*__first == *__next) erase(__next); else __first = __next; __next = __first; } } template void unique(_BinaryPredicate __binary_pred) { iterator __first = begin(); iterator __last = end(); if (__first == __last) return; iterator __next = __first; while (++__next != __last) { __profcxx_list2slist_operation(this->_M_list2slist_info); if (__binary_pred(*__first, *__next)) erase(__next); else __first = __next; __next = __first; } } void #if __cplusplus >= 201103L merge(list&& __x) #else merge(list& __x) #endif { _Base::merge(_GLIBCXX_MOVE(__x._M_base())); } #if __cplusplus >= 201103L void merge(list& __x) { this->merge(std::move(__x)); } #endif template void #if __cplusplus >= 201103L merge(list&& __x, _Compare __comp) #else merge(list& __x, _Compare __comp) #endif { _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); } #if __cplusplus >= 201103L template void merge(list& __x, _Compare __comp) { this->merge(std::move(__x), __comp); } #endif _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } void _M_profile_iterate(int __rewind = 0) const { __profcxx_list2slist_operation(this->_M_list2slist_info); __profcxx_list2vector_iterate(this->_M_list2vector_info, __rewind); if (__rewind) __profcxx_list2slist_rewind(this->_M_list2slist_info); } private: size_type _M_profile_insert(const_iterator __pos, size_type __size) { size_type __shift = 0; typename _Base::const_iterator __it = __pos.base(); for (; __it != _Base::end(); ++__it) __shift++; __profcxx_list2slist_rewind(this->_M_list2slist_info); __profcxx_list2slist_operation(this->_M_list2slist_info); __profcxx_list2vector_insert(this->_M_list2vector_info, __shift, __size); } }; template inline bool operator==(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() == __rhs._M_base(); } template inline bool operator!=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() != __rhs._M_base(); } template inline bool operator<(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() < __rhs._M_base(); } template inline bool operator<=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() <= __rhs._M_base(); } template inline bool operator>=(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() >= __rhs._M_base(); } template inline bool operator>(const list<_Tp, _Alloc>& __lhs, const list<_Tp, _Alloc>& __rhs) { return __lhs._M_base() > __rhs._M_base(); } template inline void swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs) _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } } // namespace __profile } // namespace std #endif c++/8/profile/bitset000064400000014717152640040220010145 0ustar00// Profiling bitset implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/bitset * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_BITSET #define _GLIBCXX_PROFILE_BITSET #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::bitset wrapper with performance instrumentation, none at the /// moment. template class bitset : public _GLIBCXX_STD_C::bitset<_Nb> { typedef _GLIBCXX_STD_C::bitset<_Nb> _Base; public: // 23.3.5.1 constructors: #if __cplusplus < 201103L bitset() : _Base() { } #else constexpr bitset() = default; #endif #if __cplusplus >= 201103L constexpr bitset(unsigned long long __val) noexcept #else bitset(unsigned long __val) #endif : _Base(__val) { } template explicit bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type __pos = 0, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos)) : _Base(__str, __pos, __n) { } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 396. what are characters zero and one. template bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type __pos, typename std::basic_string<_CharT, _Traits, _Alloc>::size_type __n, _CharT __zero, _CharT __one = _CharT('1')) : _Base(__str, __pos, __n, __zero, __one) { } bitset(const _Base& __x) : _Base(__x) { } #if __cplusplus >= 201103L template explicit bitset(const _CharT* __str, typename std::basic_string<_CharT>::size_type __n = std::basic_string<_CharT>::npos, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) : _Base(__str, __n, __zero, __one) { } #endif // 23.3.5.2 bitset operations: bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { _M_base() &= __rhs; return *this; } bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { _M_base() |= __rhs; return *this; } bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { _M_base() ^= __rhs; return *this; } bitset<_Nb>& operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT { _M_base() <<= __pos; return *this; } bitset<_Nb>& operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT { _M_base() >>= __pos; return *this; } bitset<_Nb>& set() _GLIBCXX_NOEXCEPT { _Base::set(); return *this; } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 186. bitset::set() second parameter should be bool bitset<_Nb>& set(size_t __pos, bool __val = true) { _Base::set(__pos, __val); return *this; } bitset<_Nb>& reset() _GLIBCXX_NOEXCEPT { _Base::reset(); return *this; } bitset<_Nb>& reset(size_t __pos) { _Base::reset(__pos); return *this; } bitset<_Nb> operator~() const _GLIBCXX_NOEXCEPT { return bitset(~_M_base()); } bitset<_Nb>& flip() _GLIBCXX_NOEXCEPT { _Base::flip(); return *this; } bitset<_Nb>& flip(size_t __pos) { _Base::flip(__pos); return *this; } bool operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return _M_base() == __rhs; } bool operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return _M_base() != __rhs; } bitset<_Nb> operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(_M_base() << __pos); } bitset<_Nb> operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(_M_base() >> __pos); } _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } }; template bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { return bitset<_Nb>(__x) &= __y; } template bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { return bitset<_Nb>(__x) |= __y; } template bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { return bitset<_Nb>(__x) ^= __y; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) { return __is >> __x._M_base(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x) { return __os << __x._M_base(); } } // namespace __profile #if __cplusplus >= 201103L // DR 1182. /// std::hash specialization for bitset. template struct hash<__profile::bitset<_Nb>> : public __hash_base> { size_t operator()(const __profile::bitset<_Nb>& __b) const noexcept { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); } }; #endif } // namespace std #endif c++/8/profile/set000064400000002336152640040220007440 0ustar00// Profiling set/multiset implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/set * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_SET #define _GLIBCXX_PROFILE_SET 1 #include #include #include #endif c++/8/profile/iterator_tracker.h000064400000022522152640040220012436 0ustar00// Profiling iterator implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/iterator_tracker.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_ITERATOR_TRACKER #define _GLIBCXX_PROFILE_ITERATOR_TRACKER 1 #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template class __iterator_tracker { typedef __iterator_tracker _Self; // The underlying iterator _Iterator _M_current; // The underlying data structure const _Sequence* _M_ds; typedef std::iterator_traits<_Iterator> _Traits; public: typedef _Iterator _Base_iterator; typedef typename _Traits::iterator_category iterator_category; typedef typename _Traits::value_type value_type; typedef typename _Traits::difference_type difference_type; typedef typename _Traits::reference reference; typedef typename _Traits::pointer pointer; __iterator_tracker() _GLIBCXX_NOEXCEPT : _M_current(), _M_ds(0) { } __iterator_tracker(const _Iterator& __i, const _Sequence* __seq) _GLIBCXX_NOEXCEPT : _M_current(__i), _M_ds(__seq) { } __iterator_tracker(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT : _M_current(__x._M_current), _M_ds(__x._M_ds) { } template __iterator_tracker(const __iterator_tracker<_MutableIterator, typename __gnu_cxx::__enable_if <(std::__are_same<_MutableIterator, typename _Sequence::iterator::_Base_iterator>::__value), _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT : _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { } _Iterator base() const _GLIBCXX_NOEXCEPT { return _M_current; } /** * @brief Conversion to underlying non-debug iterator to allow * better interaction with non-profile containers. */ operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; } pointer operator->() const _GLIBCXX_NOEXCEPT { return &*_M_current; } __iterator_tracker& operator++() _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(); ++_M_current; return *this; } __iterator_tracker operator++(int) _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(); __iterator_tracker __tmp(*this); ++_M_current; return __tmp; } __iterator_tracker& operator--() _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(1); --_M_current; return *this; } __iterator_tracker operator--(int) _GLIBCXX_NOEXCEPT { _M_ds->_M_profile_iterate(1); __iterator_tracker __tmp(*this); --_M_current; return __tmp; } __iterator_tracker& operator=(const __iterator_tracker& __x) _GLIBCXX_NOEXCEPT { _M_current = __x._M_current; _M_ds = __x._M_ds; return *this; } reference operator*() const _GLIBCXX_NOEXCEPT { return *_M_current; } // ------ Random access iterator requirements ------ reference operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT { return _M_current[__n]; } __iterator_tracker& operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT { _M_current += __n; return *this; } __iterator_tracker operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT { __iterator_tracker __tmp(*this); __tmp += __n; return __tmp; } __iterator_tracker& operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT { _M_current += -__n; return *this; } __iterator_tracker operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT { __iterator_tracker __tmp(*this); __tmp -= __n; return __tmp; } const _Sequence* _M_get_sequence() const { return static_cast(_M_ds); } }; template inline bool operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() == __rhs.base(); } template inline bool operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() == __rhs.base(); } template inline bool operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() != __rhs.base(); } template inline bool operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() != __rhs.base(); } template inline bool operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() < __rhs.base(); } template inline bool operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() < __rhs.base(); } template inline bool operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() <= __rhs.base(); } template inline bool operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() <= __rhs.base(); } template inline bool operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() > __rhs.base(); } template inline bool operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() > __rhs.base(); } template inline bool operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() >= __rhs.base(); } template inline bool operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() >= __rhs.base(); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // According to the resolution of DR179 not only the various comparison // operators but also operator- must accept mixed iterator/const_iterator // parameters. template inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, const __iterator_tracker<_IteratorR, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() - __rhs.base(); } template inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs, const __iterator_tracker<_Iterator, _Sequence>& __rhs) _GLIBCXX_NOEXCEPT { return __lhs.base() - __rhs.base(); } template inline __iterator_tracker<_Iterator, _Sequence> operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type __n, const __iterator_tracker<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT { return __i + __n; } } // namespace __profile } // namespace std #endif c++/8/profile/forward_list000064400000014366152640040220011352 0ustar00// -*- C++ -*- // Copyright (C) 2010-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/forward_list * This file is a GNU debug extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_FORWARD_LIST #define _GLIBCXX_PROFILE_FORWARD_LIST 1 #if __cplusplus < 201103L # include #else #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::forward_list wrapper with performance instrumentation. template > class forward_list : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> { typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base; public: typedef typename _Base::size_type size_type; typedef typename _Base::const_iterator const_iterator; // 23.2.3.1 construct/copy/destroy: forward_list() = default; explicit forward_list(const _Alloc& __al) noexcept : _Base(__al) { } forward_list(const forward_list& __list, const _Alloc& __al) : _Base(__list, __al) { } forward_list(forward_list&& __list, const _Alloc& __al) : _Base(std::move(__list), __al) { } explicit forward_list(size_type __n, const _Alloc& __al = _Alloc()) : _Base(__n, __al) { } forward_list(size_type __n, const _Tp& __value, const _Alloc& __al = _Alloc()) : _Base(__n, __value, __al) { } template> forward_list(_InputIterator __first, _InputIterator __last, const _Alloc& __al = _Alloc()) : _Base(__first, __last, __al) { } forward_list(const forward_list&) = default; forward_list(forward_list&&) = default; forward_list(std::initializer_list<_Tp> __il, const _Alloc& __al = _Alloc()) : _Base(__il, __al) { } ~forward_list() = default; forward_list& operator=(const forward_list&) = default; forward_list& operator=(forward_list&&) = default; forward_list& operator=(std::initializer_list<_Tp> __il) { _M_base() = __il; return *this; } void swap(forward_list& __fl) noexcept( noexcept(declval<_Base&>().swap(__fl)) ) { _Base::swap(__fl); } void splice_after(const_iterator __pos, forward_list&& __fl) { _Base::splice_after(__pos, std::move(__fl)); } void splice_after(const_iterator __pos, forward_list& __list) { _Base::splice_after(__pos, __list); } void splice_after(const_iterator __pos, forward_list&& __list, const_iterator __i) { _Base::splice_after(__pos, std::move(__list), __i); } void splice_after(const_iterator __pos, forward_list& __list, const_iterator __i) { _Base::splice_after(__pos, __list, __i); } void splice_after(const_iterator __pos, forward_list&& __list, const_iterator __before, const_iterator __last) { _Base::splice_after(__pos, std::move(__list), __before, __last); } void splice_after(const_iterator __pos, forward_list& __list, const_iterator __before, const_iterator __last) { _Base::splice_after(__pos, __list, __before, __last); } void merge(forward_list&& __list) { _Base::merge(std::move(__list)); } void merge(forward_list& __list) { _Base::merge(__list); } template void merge(forward_list&& __list, _Comp __comp) { _Base::merge(std::move(__list), __comp); } template void merge(forward_list& __list, _Comp __comp) { _Base::merge(__list, __comp); } _Base& _M_base() noexcept { return *this; } const _Base& _M_base() const noexcept { return *this; } }; template inline bool operator==(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return __lx._M_base() == __ly._M_base(); } template inline bool operator<(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return __lx._M_base() < __ly._M_base(); } template inline bool operator!=(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return !(__lx == __ly); } /// Based on operator< template inline bool operator>(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return (__ly < __lx); } /// Based on operator< template inline bool operator>=(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return !(__lx < __ly); } /// Based on operator< template inline bool operator<=(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { return !(__ly < __lx); } /// See std::forward_list::swap(). template inline void swap(forward_list<_Tp, _Alloc>& __lx, forward_list<_Tp, _Alloc>& __ly) noexcept(noexcept(__lx.swap(__ly))) { __lx.swap(__ly); } } // namespace __profile } // namespace std #endif // C++11 #endif c++/8/profile/multiset.h000064400000044741152640040220010747 0ustar00// Profiling multiset implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/multiset.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_MULTISET_H #define _GLIBCXX_PROFILE_MULTISET_H 1 #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::multiset wrapper with performance instrumentation. template, typename _Allocator = std::allocator<_Key> > class multiset : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>, public _Ordered_profile > { typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base; typedef typename _Base::iterator _Base_iterator; typedef typename _Base::const_iterator _Base_const_iterator; public: // types: typedef _Key key_type; typedef _Key value_type; typedef _Compare key_compare; typedef _Compare value_compare; typedef _Allocator allocator_type; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, multiset> iterator; typedef __iterator_tracker<_Base_const_iterator, multiset> const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; // 23.3.3.1 construct/copy/destroy: #if __cplusplus < 201103L multiset() : _Base() { } multiset(const multiset& __x) : _Base(__x) { } ~multiset() { } #else multiset() = default; multiset(const multiset&) = default; multiset(multiset&&) = default; ~multiset() = default; #endif explicit multiset(const _Compare& __comp, const _Allocator& __a = _Allocator()) : _Base(__comp, __a) { } #if __cplusplus >= 201103L template> #else template #endif multiset(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } #if __cplusplus >= 201103L multiset(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _Base(__l, __comp, __a) { } explicit multiset(const allocator_type& __a) : _Base(__a) { } multiset(const multiset& __x, const allocator_type& __a) : _Base(__x, __a) { } multiset(multiset&& __x, const allocator_type& __a) noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } multiset(initializer_list __l, const allocator_type& __a) : _Base(__l, __a) { } template multiset(_InputIterator __first, _InputIterator __last, const allocator_type& __a) : _Base(__first, __last, __a) { } #endif multiset(const _Base& __x) : _Base(__x) { } #if __cplusplus < 201103L multiset& operator=(const multiset& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else multiset& operator=(const multiset&) = default; multiset& operator=(multiset&&) = default; multiset& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::end(), this); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::cend(), this); } #endif reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_reverse_iterator crbegin() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cend()); } const_reverse_iterator crend() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cbegin()); } #endif void swap(multiset& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } // modifiers: #if __cplusplus >= 201103L template iterator emplace(_Args&&... __args) { // The cost is the same whether or not the element is inserted so we // always report insertion of 1 element. __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::emplace(std::forward<_Args>(__args)...), this); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { auto size_before = this->size(); auto __res = _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif iterator insert(const value_type& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::insert(__x), this); } #if __cplusplus >= 201103L iterator insert(value_type&& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::insert(std::move(__x)), this); } #endif iterator insert(const_iterator __pos, const value_type& __x) { size_type size_before = this->size(); _Base_iterator __res = _Base::insert(__pos.base(), __x); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #if __cplusplus >= 201103L iterator insert(const_iterator __pos, value_type&& __x) { auto size_before = this->size(); auto __res = _Base::insert(__pos.base(), std::move(__x)); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif #if __cplusplus >= 201103L template> #else template #endif void insert(_InputIterator __first, _InputIterator __last) { for (; __first != __last; ++__first) insert(*__first); } #if __cplusplus >= 201103L void insert(initializer_list __l) { insert(__l.begin(), __l.end()); } #endif #if __cplusplus >= 201103L iterator erase(const_iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } #else void erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); _Base::erase(__pos.base()); } #endif size_type erase(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) { if (__first != __last) { iterator __ret; for (; __first != __last;) __ret = erase(__first++); return __ret; } else return iterator(_Base::erase(__first.base(), __last.base()), this); } #else void erase(iterator __first, iterator __last) { for (; __first != __last;) erase(__first++); } #endif void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } size_type count(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #if __cplusplus > 201103L template::type> size_type count(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #endif // multiset operations: iterator find(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return iterator(_Base::find(__x), this); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator find(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return const_iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> iterator find(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } template::type> const_iterator find(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif iterator lower_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return iterator(_Base::lower_bound(__x), this); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator lower_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator lower_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } template::type> const_iterator lower_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif iterator upper_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::upper_bound(__x), this); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload const_iterator upper_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator upper_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } template::type> const_iterator upper_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif std::pair equal_range(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_iterator, _Base_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(iterator(__base_ret.first, this), iterator(__base_ret.second, this)); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 214. set::find() missing const overload std::pair equal_range(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_const_iterator, _Base_const_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(const_iterator(__base_ret.first, this), const_iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } template::type> std::pair equal_range(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } private: /** If hint is used we consider that the map and unordered_map * operations have equivalent insertion cost so we do not update metrics * about it. * Note that to find out if hint has been used is libstdc++ * implementation dependent. */ bool _M_hint_used(_Base_const_iterator __hint, _Base_iterator __res) { return (__hint == __res || (__hint == _M_base().end() && ++__res == _M_base().end()) || (__hint != _M_base().end() && (++__hint == __res || ++__res == --__hint))); } template friend bool operator==(const multiset<_K1, _C1, _A1>&, const multiset<_K1, _C1, _A1>&); template friend bool operator< (const multiset<_K1, _C1, _A1>&, const multiset<_K1, _C1, _A1>&); }; template inline bool operator==(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() == __rhs._M_base(); } template inline bool operator<(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() < __rhs._M_base(); } template inline bool operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { return !(__lhs == __rhs); } template inline bool operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { return !(__rhs < __lhs); } template inline bool operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { return !(__lhs < __rhs); } template inline bool operator>(const multiset<_Key, _Compare, _Allocator>& __lhs, const multiset<_Key, _Compare, _Allocator>& __rhs) { return __rhs < __lhs; } template void swap(multiset<_Key, _Compare, _Allocator>& __x, multiset<_Key, _Compare, _Allocator>& __y) _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y))) { return __x.swap(__y); } } // namespace __profile } // namespace std #endif c++/8/profile/map000064400000002336152640040220007422 0ustar00// Profiling map/multimap implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/map * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_MAP #define _GLIBCXX_PROFILE_MAP 1 #include #include #include #endif c++/8/profile/base.h000064400000003255152640040220010006 0ustar00// -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/base.h * @brief Sequential helper functions. * This file is a GNU profile extension to the Standard C++ Library. */ // Written by Lixia Liu #ifndef _GLIBCXX_PROFILE_BASE_H #define _GLIBCXX_PROFILE_BASE_H 1 #include // Profiling mode namespaces. /** * @namespace std::__profile * @brief GNU profile code, replaces standard behavior with profile behavior. */ namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { } } /** * @namespace __gnu_profile * @brief GNU profile code for public use. */ namespace __gnu_profile { // Import all the profile versions of components in namespace std. using namespace std::__profile; } #endif /* _GLIBCXX_PROFILE_BASE_H */ c++/8/profile/multimap.h000064400000045606152640040220010732 0ustar00// Profiling multimap implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/multimap.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_MULTIMAP_H #define _GLIBCXX_PROFILE_MULTIMAP_H 1 #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::multimap wrapper with performance instrumentation. template, typename _Allocator = std::allocator > > class multimap : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>, public _Ordered_profile > { typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base; typedef typename _Base::iterator _Base_iterator; typedef typename _Base::const_iterator _Base_const_iterator; public: // types: typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair value_type; typedef _Compare key_compare; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, multimap> iterator; typedef __iterator_tracker<_Base_const_iterator, multimap> const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; // 23.3.1.1 construct/copy/destroy: #if __cplusplus < 201103L multimap() : _Base() { } multimap(const multimap& __x) : _Base(__x) { } ~multimap() { } #else multimap() = default; multimap(const multimap&) = default; multimap(multimap&&) = default; ~multimap() = default; #endif explicit multimap(const _Compare& __comp, const _Allocator& __a = _Allocator()) : _Base(__comp, __a) { } #if __cplusplus >= 201103L template> #else template #endif multimap(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } #if __cplusplus >= 201103L multimap(initializer_list __l, const _Compare& __c = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__l, __c, __a) { } explicit multimap(const _Allocator& __a) : _Base(__a) { } multimap(const multimap& __x, const _Allocator& __a) : _Base(__x, __a) { } multimap(multimap&& __x, const _Allocator& __a) noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } multimap(initializer_list __l, const _Allocator& __a) : _Base(__l, __a) { } template multimap(_InputIterator __first, _InputIterator __last, const _Allocator& __a) : _Base(__first, __last, __a) { } #endif multimap(const _Base& __x) : _Base(__x) { } #if __cplusplus < 201103L multimap& operator=(const multimap& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else multimap& operator=(const multimap&) = default; multimap& operator=(multimap&&) = default; multimap& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::end(), this); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::cend(), this); } #endif reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_reverse_iterator crbegin() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cend()); } const_reverse_iterator crend() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cbegin()); } #endif // modifiers: #if __cplusplus >= 201103L template iterator emplace(_Args&&... __args) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::emplace(std::forward<_Args>(__args)...), this); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { auto size_before = this->size(); auto __res = _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif iterator insert(const value_type& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::insert(__x), this); } #if __cplusplus >= 201103L template::value>::type> iterator insert(_Pair&& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::insert(std::forward<_Pair>(__x)), this); } #endif #if __cplusplus >= 201103L void insert(std::initializer_list __list) { insert(__list.begin(), __list.end()); } #endif iterator #if __cplusplus >= 201103L insert(const_iterator __pos, const value_type& __x) #else insert(iterator __pos, const value_type& __x) #endif { size_type size_before = this->size(); _Base_iterator __res = _Base::insert(__pos.base(), __x); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #if __cplusplus >= 201103L template::value>::type> iterator insert(const_iterator __pos, _Pair&& __x) { size_type size_before = this->size(); auto __res = _Base::insert(__pos.base(), std::forward<_Pair>(__x)); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif template void insert(_InputIterator __first, _InputIterator __last) { for (; __first != __last; ++__first) insert(*__first); } #if __cplusplus >= 201103L iterator erase(const_iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } iterator erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } #else void erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); _Base::erase(__pos.base()); } #endif size_type erase(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) { if (__first != __last) { iterator __ret; for (; __first != __last;) __ret = erase(__first++); return __ret; } else return iterator(_Base::erase(__first.base(), __last.base()), this); } #else void erase(iterator __first, iterator __last) { for (; __first != __last;) erase(__first++); } #endif void swap(multimap& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { std::swap(this->_M_map2umap_info, __x._M_map2umap_info); _Base::swap(__x); } void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } // 23.3.1.3 multimap operations: iterator find(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> iterator find(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif const_iterator find(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return const_iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> const_iterator find(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif size_type count(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #if __cplusplus > 201103L template::type> size_type count(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #endif iterator lower_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator lower_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif const_iterator lower_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> const_iterator lower_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif iterator upper_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator upper_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif const_iterator upper_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> const_iterator upper_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif std::pair equal_range(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_iterator, _Base_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(iterator(__base_ret.first, this), iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif std::pair equal_range(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_const_iterator, _Base_const_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(const_iterator(__base_ret.first, this), const_iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } private: /** If hint is used we consider that the map and unordered_map * operations have equivalent insertion cost so we do not update metrics * about it. * Note that to find out if hint has been used is libstdc++ * implementation dependent. */ bool _M_hint_used(_Base_const_iterator __hint, _Base_iterator __res) { return (__hint == __res || (__hint == _M_base().end() && ++__res == _M_base().end()) || (__hint != _M_base().end() && (++__hint == __res || ++__res == --__hint))); } template friend bool operator==(const multimap<_K1, _T1, _C1, _A1>&, const multimap<_K1, _T1, _C1, _A1>&); template friend bool operator<(const multimap<_K1, _T1, _C1, _A1>&, const multimap<_K1, _T1, _C1, _A1>&); }; template inline bool operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() == __rhs._M_base(); } template inline bool operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() < __rhs._M_base(); } template inline bool operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__lhs == __rhs); } template inline bool operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__rhs < __lhs); } template inline bool operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__lhs < __rhs); } template inline bool operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) { return __rhs < __lhs; } template inline void swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } } // namespace __profile } // namespace std #endif c++/8/profile/set.h000064400000043311152640040230007665 0ustar00// Profiling set implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file profile/set.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_SET_H #define _GLIBCXX_PROFILE_SET_H 1 #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::set wrapper with performance instrumentation. template, typename _Allocator = std::allocator<_Key> > class set : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>, public _Ordered_profile > { typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base; typedef typename _Base::iterator _Base_iterator; typedef typename _Base::const_iterator _Base_const_iterator; public: // types: typedef _Key key_type; typedef _Key value_type; typedef _Compare key_compare; typedef _Compare value_compare; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, set> iterator; typedef __iterator_tracker<_Base_const_iterator, set> const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; // 23.3.3.1 construct/copy/destroy: #if __cplusplus < 201103L set() : _Base() { } set(const set& __x) : _Base(__x) { } ~set() { } #else set() = default; set(const set&) = default; set(set&&) = default; ~set() = default; #endif explicit set(const _Compare& __comp, const _Allocator& __a = _Allocator()) : _Base(__comp, __a) { } #if __cplusplus >= 201103L template> #else template #endif set(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } #if __cplusplus >= 201103L set(initializer_list __l, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__l, __comp, __a) { } explicit set(const _Allocator& __a) : _Base(__a) { } set(const set& __x, const _Allocator& __a) : _Base(__x, __a) { } set(set&& __x, const _Allocator& __a) noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } set(initializer_list __l, const _Allocator& __a) : _Base(__l, __a) { } template set(_InputIterator __first, _InputIterator __last, const _Allocator& __a) : _Base(__first, __last, __a) { } #endif set(const _Base& __x) : _Base(__x) { } #if __cplusplus < 201103L set& operator=(const set& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else set& operator=(const set&) = default; set& operator=(set&&) = default; set& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::end(), this); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::cend(), this); } #endif reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_reverse_iterator crbegin() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cend()); } const_reverse_iterator crend() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cbegin()); } #endif void swap(set& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } // modifiers: #if __cplusplus >= 201103L template std::pair emplace(_Args&&... __args) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); auto __base_ret = _Base::emplace(std::forward<_Args>(__args)...); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { auto size_before = this->size(); auto __res = _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif std::pair insert(const value_type& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); std::pair<_Base_iterator, bool> __base_ret = _Base::insert(__x); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } #if __cplusplus >= 201103L std::pair insert(value_type&& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); std::pair<_Base_iterator, bool> __base_ret = _Base::insert(std::move(__x)); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } #endif iterator insert(const_iterator __pos, const value_type& __x) { size_type size_before = this->size(); _Base_iterator __res = _Base::insert(__pos.base(), __x); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #if __cplusplus >= 201103L iterator insert(const_iterator __pos, value_type&& __x) { return iterator(_Base::insert(__pos.base(), std::move(__x)), this); } #endif template void insert(_InputIterator __first, _InputIterator __last) { for (; __first != __last; ++__first) insert(*__first); } #if __cplusplus >= 201103L void insert(initializer_list __l) { insert(__l.begin(), __l.end()); } #endif #if __cplusplus >= 201103L iterator erase(const_iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } #else void erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); _Base::erase(__pos.base()); } #endif size_type erase(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) { if (__first != __last) { iterator __ret; for (; __first != __last;) __ret = erase(__first++); return __ret; } return iterator(_Base::erase(__first.base(), __last.base()), this); } #else void erase(iterator __first, iterator __last) { for (; __first != __last;) erase(__first++); } #endif void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } size_type count(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #if __cplusplus > 201103L template::type> size_type count(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #endif // set operations: iterator find(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return iterator(_Base::find(__x), this); } const_iterator find(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return const_iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> iterator find(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } template::type> const_iterator find(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif iterator lower_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::lower_bound(__x), this); } const_iterator lower_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator lower_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } template::type> const_iterator lower_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif iterator upper_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::upper_bound(__x), this); } const_iterator upper_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator upper_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } template::type> const_iterator upper_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif std::pair equal_range(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_iterator, _Base_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(iterator(__base_ret.first, this), iterator(__base_ret.second, this)); } std::pair equal_range(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_const_iterator, _Base_const_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(const_iterator(__base_ret.first, this), const_iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } template::type> std::pair equal_range(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } private: /** If hint is used we consider that the map and unordered_map * operations have equivalent insertion cost so we do not update metrics * about it. * Note that to find out if hint has been used is libstdc++ * implementation dependent. */ bool _M_hint_used(_Base_const_iterator __hint, _Base_iterator __res) { return (__hint == __res || (__hint == _M_base().end() && ++__res == _M_base().end()) || (__hint != _M_base().end() && (++__hint == __res || ++__res == --__hint))); } template friend bool operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); template friend bool operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); }; template inline bool operator==(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() == __rhs._M_base(); } template inline bool operator<(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() < __rhs._M_base(); } template inline bool operator!=(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { return !(__lhs == __rhs); } template inline bool operator<=(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { return !(__rhs < __lhs); } template inline bool operator>=(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { return !(__lhs < __rhs); } template inline bool operator>(const set<_Key, _Compare, _Allocator>& __lhs, const set<_Key, _Compare, _Allocator>& __rhs) { return __rhs < __lhs; } template void swap(set<_Key, _Compare, _Allocator>& __x, set<_Key, _Compare, _Allocator>& __y) _GLIBCXX_NOEXCEPT_IF(noexcept(__x.swap(__y))) { return __x.swap(__y); } } // namespace __profile } // namespace std #endif c++/8/profile/unordered_base.h000064400000021634152640040230012057 0ustar00// Profiling unordered containers implementation details -*- C++ -*- // Copyright (C) 2013-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/unordered_base.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_UNORDERED #define _GLIBCXX_PROFILE_UNORDERED 1 namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template struct _Bucket_index_helper; template struct _Bucket_index_helper<_UnorderedCont, _Value, true> { static std::size_t bucket(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, true>* __node) { return __node->_M_hash_code % __uc.bucket_count(); } }; template struct _Bucket_index_helper<_UnorderedCont, _Value, false> { static std::size_t bucket(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, false>* __node) { return __uc.bucket(__node->_M_v()); } }; template struct _Bucket_index_helper<_UnorderedCont, std::pair, false> { typedef std::pair _Value; static std::size_t bucket(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, false>* __node) { return __uc.bucket(__node->_M_v().first); } }; template std::size_t __get_bucket_index(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, _Cache_hash_code>* __node) { using __bucket_index_helper = _Bucket_index_helper<_UnorderedCont, _Value, _Cache_hash_code>; return __bucket_index_helper::bucket(__uc, __node); } template struct _Equal_helper; template struct _Equal_helper<_UnorderedCont, _Value, true> { static std::size_t are_equal(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, true>* __lhs, const __detail::_Hash_node<_Value, true>* __rhs) { return __lhs->_M_hash_code == __rhs->_M_hash_code && __uc.key_eq()(__lhs->_M_v(), __rhs->_M_v()); } }; template struct _Equal_helper<_UnorderedCont, _Value, false> { static std::size_t are_equal(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, false>* __lhs, const __detail::_Hash_node<_Value, false>* __rhs) { return __uc.key_eq()(__lhs->_M_v(), __rhs->_M_v()); } }; template struct _Equal_helper<_UnorderedCont, std::pair, true> { typedef std::pair _Value; static std::size_t are_equal(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, true>* __lhs, const __detail::_Hash_node<_Value, true>* __rhs) { return __lhs->_M_hash_code == __rhs->_M_hash_code && __uc.key_eq()(__lhs->_M_v().first, __rhs->_M_v().first); } }; template struct _Equal_helper<_UnorderedCont, std::pair, false> { typedef std::pair _Value; static std::size_t are_equal(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, false>* __lhs, const __detail::_Hash_node<_Value, false>* __rhs) { return __uc.key_eq()(__lhs->_M_v().first, __rhs->_M_v().first); } }; template bool __are_equal(const _UnorderedCont& __uc, const __detail::_Hash_node<_Value, _Cache_hash_code>* __lhs, const __detail::_Hash_node<_Value, _Cache_hash_code>* __rhs) { using __equal_helper = _Equal_helper<_UnorderedCont, _Value, _Cache_hash_code>; return __equal_helper::are_equal(__uc, __lhs, __rhs); } template class _Unordered_profile { _UnorderedCont& _M_conjure() { return *(static_cast<_UnorderedCont*>(this)); } using __unique_keys = std::integral_constant; protected: _Unordered_profile() noexcept { _M_profile_construct(); } _Unordered_profile(const _Unordered_profile&) noexcept : _Unordered_profile() { } _Unordered_profile(_Unordered_profile&& __other) noexcept : _Unordered_profile() { _M_swap(__other); } ~_Unordered_profile() { _M_profile_destruct(); } _Unordered_profile& operator=(const _Unordered_profile&) noexcept { // Assignment just reset profiling. _M_profile_destruct(); _M_profile_construct(); } _Unordered_profile& operator=(_Unordered_profile&& __other) noexcept { // Take profiling of the moved instance... _M_swap(__other); // ...and then reset other instance profiling. __other._M_profile_destruct(); __other._M_profile_construct(); } void _M_profile_construct() noexcept { auto& __uc = _M_conjure(); _M_size_info = __profcxx_hashtable_size_construct(__uc.bucket_count()); _M_hashfunc_info = __profcxx_hash_func_construct(); } void _M_profile_destruct() noexcept { auto& __uc = _M_conjure(); __profcxx_hashtable_size_destruct(_M_size_info, __uc.bucket_count(), __uc.size()); _M_size_info = 0; if (!_M_hashfunc_info) return; _M_profile_destruct(__unique_keys()); _M_hashfunc_info = 0; } void _M_swap(_Unordered_profile& __other) noexcept { std::swap(_M_size_info, __other._M_size_info); std::swap(_M_hashfunc_info, __other._M_hashfunc_info); } void _M_profile_resize(std::size_t __old_size) { auto __new_size = _M_conjure().bucket_count(); if (__old_size != __new_size) __profcxx_hashtable_size_resize(_M_size_info, __old_size, __new_size); } __gnu_profile::__container_size_info* _M_size_info; __gnu_profile::__hashfunc_info* _M_hashfunc_info; private: void _M_profile_destruct(std::true_type); void _M_profile_destruct(std::false_type); }; template void _Unordered_profile<_UnorderedCont, _Unique_keys>:: _M_profile_destruct(std::true_type) { auto& __uc = _M_conjure(); std::size_t __hops = 0, __lc = 0, __chain = 0; auto __it = __uc.begin(); while (__it != __uc.end()) { auto __bkt = __get_bucket_index(__uc, __it._M_cur); auto __lit = __uc.begin(__bkt); auto __lend = __uc.end(__bkt); for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit) ++__chain; if (__chain) { ++__chain; __lc = __lc > __chain ? __lc : __chain; __hops += __chain * (__chain - 1) / 2; __chain = 0; } } __profcxx_hash_func_destruct(_M_hashfunc_info, __lc, __uc.size(), __hops); } template void _Unordered_profile<_UnorderedCont, _Unique_keys>:: _M_profile_destruct(std::false_type) { auto& __uc = _M_conjure(); std::size_t __hops = 0, __lc = 0, __chain = 0, __unique_size = 0; auto __it = __uc.begin(); while (__it != __uc.end()) { auto __bkt = __get_bucket_index(__uc, __it._M_cur); auto __lit = __uc.begin(__bkt); auto __lend = __uc.end(__bkt); auto __pit = __it; ++__unique_size; for (++__it, ++__lit; __lit != __lend; ++__it, ++__lit) { if (!__are_equal(__uc, __pit._M_cur, __it._M_cur)) { ++__chain; ++__unique_size; __pit = __it; } } if (__chain) { ++__chain; __lc = __lc > __chain ? __lc : __chain; __hops += __chain * (__chain - 1) / 2; __chain = 0; } } __profcxx_hash_func_destruct(_M_hashfunc_info, __lc, __unique_size, __hops); } } // namespace __profile } // namespace std #endif c++/8/profile/unordered_set000064400000037643152640040230011521 0ustar00// Profiling unordered_set/unordered_multiset implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/unordered_set * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_UNORDERED_SET #define _GLIBCXX_PROFILE_UNORDERED_SET 1 #if __cplusplus < 201103L # include #else # include #include #include #define _GLIBCXX_BASE unordered_set<_Key, _Hash, _Pred, _Alloc> #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /** @brief Unordered_set wrapper with performance instrumentation. */ template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator<_Key> > class unordered_set : public _GLIBCXX_STD_BASE, public _Unordered_profile, true> { typedef _GLIBCXX_STD_BASE _Base; _Base& _M_base() noexcept { return *this; } const _Base& _M_base() const noexcept { return *this; } public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; typedef typename _Base::key_type key_type; typedef typename _Base::value_type value_type; typedef typename _Base::difference_type difference_type; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; unordered_set() = default; explicit unordered_set(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_set(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_set(const unordered_set&) = default; unordered_set(const _Base& __x) : _Base(__x) { } unordered_set(unordered_set&&) = default; explicit unordered_set(const allocator_type& __a) : _Base(__a) { } unordered_set(const unordered_set& __uset, const allocator_type& __a) : _Base(__uset._M_base(), __a) { } unordered_set(unordered_set&& __uset, const allocator_type& __a) : _Base(std::move(__uset._M_base()), __a) { } unordered_set(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__l, __n, __hf, __eql, __a) { } unordered_set(size_type __n, const allocator_type& __a) : unordered_set(__n, hasher(), key_equal(), __a) { } unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__n, __hf, key_equal(), __a) { } template unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__first, __last, __n, __hf, key_equal(), __a) { } unordered_set(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_set(__l, __n, hasher(), key_equal(), __a) { } unordered_set(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__l, __n, __hf, key_equal(), __a) { } unordered_set& operator=(const unordered_set&) = default; unordered_set& operator=(unordered_set&&) = default; unordered_set& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } void swap(unordered_set& __x) noexcept( noexcept(__x._M_base().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } void clear() noexcept { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } template std::pair emplace(_Args&&... __args) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::emplace(std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } template iterator emplace_hint(const_iterator __it, _Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace_hint(__it, std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } void insert(std::initializer_list __l) { size_type __old_size = _Base::bucket_count(); _Base::insert(__l); this->_M_profile_resize(__old_size); } std::pair insert(const value_type& __obj) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::insert(__obj); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, const value_type& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, __v); this->_M_profile_resize(__old_size); return __res; } std::pair insert(value_type&& __obj) { size_type __old_size = _Base::bucket_count(); std::pair __res = _Base::insert(std::move(__obj)); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, value_type&& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::move(__v)); this->_M_profile_resize(__old_size); return __res; } template void insert(_InputIter __first, _InputIter __last) { size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); this->_M_profile_resize(__old_size); } void rehash(size_type __n) { size_type __old_size = _Base::bucket_count(); _Base::rehash(__n); this->_M_profile_resize(__old_size); } }; template inline void swap(unordered_set<_Key, _Hash, _Pred, _Alloc>& __x, unordered_set<_Key, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x, const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y) { return static_cast(__x) == __y; } template inline bool operator!=(const unordered_set<_Key, _Hash, _Pred, _Alloc>& __x, const unordered_set<_Key, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } #undef _GLIBCXX_BASE #undef _GLIBCXX_STD_BASE #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE #define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc> /** @brief Unordered_multiset wrapper with performance instrumentation. */ template, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value> > class unordered_multiset : public _GLIBCXX_STD_BASE, public _Unordered_profile, false> { typedef _GLIBCXX_STD_BASE _Base; _Base& _M_base() noexcept { return *this; } const _Base& _M_base() const noexcept { return *this; } public: typedef typename _Base::size_type size_type; typedef typename _Base::hasher hasher; typedef typename _Base::key_equal key_equal; typedef typename _Base::allocator_type allocator_type; typedef typename _Base::key_type key_type; typedef typename _Base::value_type value_type; typedef typename _Base::difference_type difference_type; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; unordered_multiset() = default; explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__n, __hf, __eql, __a) { } template unordered_multiset(_InputIterator __f, _InputIterator __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__f, __l, __n, __hf, __eql, __a) { } unordered_multiset(const unordered_multiset&) = default; unordered_multiset(const _Base& __x) : _Base(__x) { } unordered_multiset(unordered_multiset&&) = default; explicit unordered_multiset(const allocator_type& __a) : _Base(__a) { } unordered_multiset(const unordered_multiset& __umset, const allocator_type& __a) : _Base(__umset._M_base(), __a) { } unordered_multiset(unordered_multiset&& __umset, const allocator_type& __a) : _Base(std::move(__umset._M_base()), __a) { } unordered_multiset(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Base(__l, __n, __hf, __eql, __a) { } unordered_multiset(size_type __n, const allocator_type& __a) : unordered_multiset(__n, hasher(), key_equal(), __a) { } unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__n, __hf, key_equal(), __a) { } template unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) { } unordered_multiset(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_multiset(__l, __n, hasher(), key_equal(), __a) { } unordered_multiset(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__l, __n, __hf, key_equal(), __a) { } unordered_multiset& operator=(const unordered_multiset&) = default; unordered_multiset& operator=(unordered_multiset&&) = default; unordered_multiset& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } void swap(unordered_multiset& __x) noexcept( noexcept(__x._M_base().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } void clear() noexcept { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } template iterator emplace(_Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace(std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } template iterator emplace_hint(const_iterator __it, _Args&&... __args) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::emplace_hint(__it, std::forward<_Args>(__args)...); this->_M_profile_resize(__old_size); return __res; } void insert(std::initializer_list __l) { size_type __old_size = _Base::bucket_count(); _Base::insert(__l); this->_M_profile_resize(__old_size); } iterator insert(const value_type& __obj) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__obj); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, const value_type& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, __v); this->_M_profile_resize(__old_size); return __res; } iterator insert(value_type&& __obj) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(std::move(__obj)); this->_M_profile_resize(__old_size); return __res; } iterator insert(const_iterator __iter, value_type&& __v) { size_type __old_size = _Base::bucket_count(); iterator __res = _Base::insert(__iter, std::move(__v)); this->_M_profile_resize(__old_size); return __res; } template void insert(_InputIter __first, _InputIter __last) { size_type __old_size = _Base::bucket_count(); _Base::insert(__first, __last); this->_M_profile_resize(__old_size); } void rehash(size_type __n) { size_type __old_size = _Base::bucket_count(); _Base::rehash(__n); this->_M_profile_resize(__old_size); } }; template inline void swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) { return static_cast(__x) == __y; } template inline bool operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) { return !(__x == __y); } } // namespace __profile } // namespace std #undef _GLIBCXX_BASE #undef _GLIBCXX_STD_BASE #endif // C++11 #endif c++/8/profile/vector000064400000037012152640040230010147 0ustar00// Profiling vector implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/vector * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_VECTOR #define _GLIBCXX_PROFILE_VECTOR 1 #include #include #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { template class _Vector_profile_pre { _Vector& _M_conjure() { return *static_cast<_Vector*>(this); } public: #if __cplusplus >= 201103L _Vector_profile_pre() = default; _Vector_profile_pre(const _Vector_profile_pre&) = default; _Vector_profile_pre(_Vector_profile_pre&&) = default; _Vector_profile_pre& operator=(const _Vector_profile_pre&) { _M_conjure()._M_profile_destruct(); } _Vector_profile_pre& operator=(_Vector_profile_pre&&) noexcept { _M_conjure()._M_profile_destruct(); } #endif }; template class _Vector_profile_post { _Vector& _M_conjure() { return *static_cast<_Vector*>(this); } protected: __gnu_profile::__container_size_info* _M_size_info; __gnu_profile::__vector2list_info* _M_vect2list_info; _Vector_profile_post() _GLIBCXX_NOEXCEPT { _M_profile_construct(); } #if __cplusplus >= 201103L _Vector_profile_post(const _Vector_profile_post&) noexcept : _Vector_profile_post() { } _Vector_profile_post(_Vector_profile_post&& __other) noexcept : _Vector_profile_post() { _M_swap(__other); } _Vector_profile_post& operator=(const _Vector_profile_post&) noexcept { _M_profile_construct(); } _Vector_profile_post& operator=(_Vector_profile_post&& __other) noexcept { _M_swap(__other); __other._M_profile_construct(); } #endif ~_Vector_profile_post() { _M_conjure()._M_profile_destruct(); } public: void _M_profile_construct() _GLIBCXX_NOEXCEPT { _M_size_info = __profcxx_vector_size_construct(_M_conjure().capacity()); _M_vect2list_info = __profcxx_vector2list_construct(); } void _M_profile_destruct() _GLIBCXX_NOEXCEPT { __profcxx_vector2list_destruct(_M_vect2list_info); _M_vect2list_info = 0; __profcxx_vector_size_destruct(_M_size_info, _M_conjure().capacity(), _M_conjure().size()); _M_size_info = 0; } void _M_swap(_Vector_profile_post& __other) _GLIBCXX_NOEXCEPT { std::swap(_M_size_info, __other._M_size_info); std::swap(_M_vect2list_info, __other._M_vect2list_info); } }; template > class vector : public _Vector_profile_pre >, public _GLIBCXX_STD_C::vector<_Tp, _Allocator>, public _Vector_profile_post > { typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base; typedef typename _Base::iterator _Base_iterator; typedef typename _Base::const_iterator _Base_const_iterator; public: typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, vector> iterator; typedef __iterator_tracker<_Base_const_iterator, vector> const_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; typedef _Tp value_type; typedef _Allocator allocator_type; typedef typename _Base::pointer pointer; typedef typename _Base::const_pointer const_pointer; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } // 23.2.4.1 construct/copy/destroy: #if __cplusplus < 201103L vector() { } vector(const vector& __x) : _Base(__x) { } #else vector() = default; vector(const vector&) = default; vector(vector&&) = default; #endif explicit vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT : _Base(__a) { } #if __cplusplus >= 201103L explicit vector(size_type __n, const _Allocator& __a = _Allocator()) : _Base(__n, __a) { } vector(size_type __n, const _Tp& __value, const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #else explicit vector(size_type __n, const _Tp& __value = _Tp(), const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } #endif #if __cplusplus >= 201103L template> #else template #endif vector(_InputIterator __first, _InputIterator __last, const _Allocator& __a = _Allocator()) : _Base(__first, __last, __a) { } /// Construction from a normal-mode vector vector(const _Base& __x) : _Base(__x) { } #if __cplusplus >= 201103L vector(const _Base& __x, const _Allocator& __a) : _Base(__x, __a) { } vector(vector&& __x, const _Allocator& __a) : _Base(std::move(__x), __a) { } vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__l, __a) { } #endif #if __cplusplus < 201103L vector& operator=(const vector& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else vector& operator=(const vector&) = default; vector& operator=(vector&&) = default; vector& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators: iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::end(), this); } reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::begin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::end(), this); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } #endif // 23.2.4.2 capacity: #if __cplusplus >= 201103L void resize(size_type __sz) { __profcxx_vector2list_invalid_operator(this->_M_vect2list_info); _M_profile_resize(this->capacity(), __sz); _Base::resize(__sz); } void resize(size_type __sz, const _Tp& __c) { __profcxx_vector2list_invalid_operator(this->_M_vect2list_info); _M_profile_resize(this->capacity(), __sz); _Base::resize(__sz, __c); } #else void resize(size_type __sz, _Tp __c = _Tp()) { __profcxx_vector2list_invalid_operator(this->_M_vect2list_info); _M_profile_resize(this->capacity(), __sz); _Base::resize(__sz, __c); } #endif // element access: reference operator[](size_type __n) _GLIBCXX_NOEXCEPT { __profcxx_vector2list_invalid_operator(this->_M_vect2list_info); return _M_base()[__n]; } const_reference operator[](size_type __n) const _GLIBCXX_NOEXCEPT { __profcxx_vector2list_invalid_operator(this->_M_vect2list_info); return _M_base()[__n]; } // 23.2.4.3 modifiers: void push_back(const _Tp& __x) { size_type __old_size = this->capacity(); _Base::push_back(__x); _M_profile_resize(__old_size, this->capacity()); } #if __cplusplus >= 201103L void push_back(_Tp&& __x) { size_type __old_size = this->capacity(); _Base::push_back(std::move(__x)); _M_profile_resize(__old_size, this->capacity()); } #endif iterator #if __cplusplus >= 201103L insert(const_iterator __pos, const _Tp& __x) #else insert(iterator __pos, const _Tp& __x) #endif { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::begin(), this->size()); size_type __old_size = this->capacity(); _Base_iterator __res = _Base::insert(__pos.base(), __x); _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #if __cplusplus >= 201103L iterator insert(const_iterator __pos, _Tp&& __x) { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::cbegin(), this->size()); size_type __old_size = this->capacity(); _Base_iterator __res = _Base::insert(__pos.base(), __x); _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } template iterator emplace(const_iterator __pos, _Args&&... __args) { _Base_iterator __res = _Base::emplace(__pos.base(), std::forward<_Args>(__args)...); return iterator(__res, this); } iterator insert(const_iterator __pos, initializer_list __l) { return this->insert(__pos, __l.begin(), __l.end()); } #endif void swap(vector& __x) #if __cplusplus >= 201103L noexcept( noexcept(declval<_Base>().swap(__x)) ) #endif { _Base::swap(__x); this->_M_swap(__x); } #if __cplusplus >= 201103L iterator insert(const_iterator __pos, size_type __n, const _Tp& __x) { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::cbegin(), this->size()); size_type __old_size = this->capacity(); _Base_iterator __res = _Base::insert(__pos, __n, __x); _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #else void insert(iterator __pos, size_type __n, const _Tp& __x) { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::begin(), this->size()); size_type __old_size = this->capacity(); _Base::insert(__pos, __n, __x); _M_profile_resize(__old_size, this->capacity()); } #endif #if __cplusplus >= 201103L template> iterator insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::cbegin(), this->size()); size_type __old_size = this->capacity(); _Base_iterator __res = _Base::insert(__pos, __first, __last); _M_profile_resize(__old_size, this->capacity()); return iterator(__res, this); } #else template void insert(iterator __pos, _InputIterator __first, _InputIterator __last) { __profcxx_vector2list_insert(this->_M_vect2list_info, __pos.base() - _Base::begin(), this->size()); size_type __old_size = this->capacity(); _Base::insert(__pos, __first, __last); _M_profile_resize(__old_size, this->capacity()); } #endif iterator #if __cplusplus >= 201103L erase(const_iterator __pos) #else erase(iterator __pos) #endif { return iterator(_Base::erase(__pos.base()), this); } iterator #if __cplusplus >= 201103L erase(const_iterator __first, const_iterator __last) #else erase(iterator __first, iterator __last) #endif { return iterator(_Base::erase(__first.base(), __last.base()), this); } void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } inline void _M_profile_iterate(int __rewind = 0) const { __profcxx_vector2list_iterate(this->_M_vect2list_info, __rewind); } private: void _M_profile_resize(size_type __old_size, size_type __new_size) { if (__old_size < __new_size) { __profcxx_vector_size_resize(this->_M_size_info, this->size(), __new_size); __profcxx_vector2list_resize(this->_M_vect2list_info, this->size(), __new_size); } } }; template inline bool operator==(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() == __rhs._M_base(); } template inline bool operator!=(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() != __rhs._M_base(); } template inline bool operator<(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() < __rhs._M_base(); } template inline bool operator<=(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() <= __rhs._M_base(); } template inline bool operator>=(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() >= __rhs._M_base(); } template inline bool operator>(const vector<_Tp, _Alloc>& __lhs, const vector<_Tp, _Alloc>& __rhs) { return __lhs._M_base() > __rhs._M_base(); } template inline void swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs) _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } } // namespace __profile #if __cplusplus >= 201103L // DR 1182. /// std::hash specialization for vector. template struct hash<__profile::vector> : public __hash_base> { size_t operator()(const __profile::vector& __b) const noexcept { return std::hash<_GLIBCXX_STD_C::vector>()(__b._M_base()); } }; #endif } // namespace std #endif c++/8/profile/map.h000064400000047204152640040230007654 0ustar00// Profiling map implementation -*- C++ -*- // Copyright (C) 2009-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING3. If not see // . /** @file profile/map.h * This file is a GNU profile extension to the Standard C++ Library. */ #ifndef _GLIBCXX_PROFILE_MAP_H #define _GLIBCXX_PROFILE_MAP_H 1 #include #include namespace std _GLIBCXX_VISIBILITY(default) { namespace __profile { /// Class std::map wrapper with performance instrumentation. template, typename _Allocator = std::allocator > > class map : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>, public _Ordered_profile > { typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base; typedef typename _Base::iterator _Base_iterator; typedef typename _Base::const_iterator _Base_const_iterator; public: // types: typedef _Key key_type; typedef _Tp mapped_type; typedef typename _Base::value_type value_type; typedef _Compare key_compare; typedef typename _Base::reference reference; typedef typename _Base::const_reference const_reference; typedef __iterator_tracker<_Base_iterator, map> iterator; typedef __iterator_tracker<_Base_const_iterator, map> const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef typename _Base::size_type size_type; typedef typename _Base::difference_type difference_type; // 23.3.1.1 construct/copy/destroy: #if __cplusplus < 201103L map() : _Base() { } map(const map& __x) : _Base(__x) { } ~map() { } #else map() = default; map(const map&) = default; map(map&&) = default; ~map() = default; #endif explicit map(const _Compare& __comp, const _Allocator& __a = _Allocator()) : _Base(__comp, __a) { } #if __cplusplus >= 201103L template> #else template #endif map(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__first, __last, __comp, __a) { } map(const _Base& __x) : _Base(__x) { } #if __cplusplus >= 201103L map(initializer_list __l, const _Compare& __c = _Compare(), const _Allocator& __a = _Allocator()) : _Base(__l, __c, __a) { } explicit map(const _Allocator& __a) : _Base(__a) { } map(const map& __x, const _Allocator& __a) : _Base(__x, __a) { } map(map&& __x, const _Allocator& __a) noexcept( noexcept(_Base(std::move(__x), __a)) ) : _Base(std::move(__x), __a) { } map(initializer_list __l, const _Allocator& __a) : _Base(__l, __a) { } template map(_InputIterator __first, _InputIterator __last, const _Allocator& __a) : _Base(__first, __last, __a) { } #endif #if __cplusplus < 201103L map& operator=(const map& __x) { this->_M_profile_destruct(); _M_base() = __x; this->_M_profile_construct(); return *this; } #else map& operator=(const map&) = default; map& operator=(map&&) = default; map& operator=(initializer_list __l) { this->_M_profile_destruct(); _M_base() = __l; this->_M_profile_construct(); return *this; } #endif // iterators iterator begin() _GLIBCXX_NOEXCEPT { return iterator(_Base::begin(), this); } const_iterator begin() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::begin(), this); } iterator end() _GLIBCXX_NOEXCEPT { return iterator(_Base::end(), this); } const_iterator end() const _GLIBCXX_NOEXCEPT { return const_iterator(_Base::end(), this); } #if __cplusplus >= 201103L const_iterator cbegin() const noexcept { return const_iterator(_Base::cbegin(), this); } const_iterator cend() const noexcept { return const_iterator(_Base::cend(), this); } #endif reverse_iterator rbegin() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(end()); } const_reverse_iterator rbegin() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(end()); } reverse_iterator rend() _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return reverse_iterator(begin()); } const_reverse_iterator rend() const _GLIBCXX_NOEXCEPT { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(begin()); } #if __cplusplus >= 201103L const_reverse_iterator crbegin() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cend()); } const_reverse_iterator crend() const noexcept { __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_reverse_iterator(cbegin()); } #endif // 23.3.1.2 element access: mapped_type& operator[](const key_type& __k) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::operator[](__k); } #if __cplusplus >= 201103L mapped_type& operator[](key_type&& __k) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::operator[](std::move(__k)); } #endif mapped_type& at(const key_type& __k) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::at(__k); } const mapped_type& at(const key_type& __k) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::at(__k); } // modifiers: #if __cplusplus >= 201103L template std::pair emplace(_Args&&... __args) { // The cost is the same whether or not the element is inserted so we // always report insertion of 1 element. __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); auto __base_ret = _Base::emplace(std::forward<_Args>(__args)...); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { auto size_before = this->size(); auto __res = _Base::emplace_hint(__pos.base(), std::forward<_Args>(__args)...); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif std::pair insert(const value_type& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); std::pair<_Base_iterator, bool> __base_ret = _Base::insert(__x); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } #if __cplusplus >= 201103L template::value>::type> std::pair insert(_Pair&& __x) { __profcxx_map2umap_insert(this->_M_map2umap_info, this->size(), 1); auto __base_ret= _Base::insert(std::forward<_Pair>(__x)); return std::make_pair(iterator(__base_ret.first, this), __base_ret.second); } #endif #if __cplusplus >= 201103L void insert(std::initializer_list __list) { insert(__list.begin(), __list.end()); } #endif iterator #if __cplusplus >= 201103L insert(const_iterator __pos, const value_type& __x) #else insert(iterator __pos, const value_type& __x) #endif { size_type size_before = this->size(); _Base_iterator __res = _Base::insert(__pos.base(), __x); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #if __cplusplus >= 201103L template::value>::type> iterator insert(const_iterator __pos, _Pair&& __x) { size_type size_before = this->size(); auto __res = _Base::insert(__pos.base(), std::forward<_Pair>(__x)); __profcxx_map2umap_insert(this->_M_map2umap_info, size_before, _M_hint_used(__pos.base(), __res) ? 0 : 1); return iterator(__res, this); } #endif template void insert(_InputIterator __first, _InputIterator __last) { for (; __first != __last; ++__first) insert(*__first); } #if __cplusplus >= 201103L iterator erase(const_iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } iterator erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return iterator(_Base::erase(__pos.base()), this); } #else void erase(iterator __pos) { __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); _Base::erase(__pos.base()); } #endif size_type erase(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_erase(this->_M_map2umap_info, this->size(), 1); return _Base::erase(__x); } #if __cplusplus >= 201103L iterator erase(const_iterator __first, const_iterator __last) { if (__first != __last) { iterator __ret; for (; __first != __last;) __ret = erase(__first++); return __ret; } else return iterator(_Base::erase(__first.base(), __last.base()), this); } #else void erase(iterator __first, iterator __last) { for (; __first != __last;) erase(__first++); } #endif void swap(map& __x) _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) ) { _Base::swap(__x); this->_M_swap(__x); } void clear() _GLIBCXX_NOEXCEPT { this->_M_profile_destruct(); _Base::clear(); this->_M_profile_construct(); } // 23.3.1.3 map operations: iterator find(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> iterator find(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif const_iterator find(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return const_iterator(_Base::find(__x), this); } #if __cplusplus > 201103L template::type> const_iterator find(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return { _Base::find(__x), this }; } #endif size_type count(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #if __cplusplus > 201103L template::type> size_type count(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); return _Base::count(__x); } #endif iterator lower_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator lower_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif const_iterator lower_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::lower_bound(__x), this); } #if __cplusplus > 201103L template::type> const_iterator lower_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::lower_bound(__x), this }; } #endif iterator upper_bound(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> iterator upper_bound(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif const_iterator upper_bound(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return const_iterator(_Base::upper_bound(__x), this); } #if __cplusplus > 201103L template::type> const_iterator upper_bound(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); __profcxx_map2umap_invalidate(this->_M_map2umap_info); return { _Base::upper_bound(__x), this }; } #endif std::pair equal_range(const key_type& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_iterator, _Base_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(iterator(__base_ret.first, this), iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif std::pair equal_range(const key_type& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); std::pair<_Base_const_iterator, _Base_const_iterator> __base_ret = _Base::equal_range(__x); return std::make_pair(const_iterator(__base_ret.first, this), const_iterator(__base_ret.second, this)); } #if __cplusplus > 201103L template::type> std::pair equal_range(const _Kt& __x) const { __profcxx_map2umap_find(this->_M_map2umap_info, this->size()); auto __res = _Base::equal_range(__x); return { { __res.first, this }, { __res.second, this } }; } #endif _Base& _M_base() _GLIBCXX_NOEXCEPT { return *this; } const _Base& _M_base() const _GLIBCXX_NOEXCEPT { return *this; } private: /** If hint is used we consider that the map and unordered_map * operations have equivalent insertion cost so we do not update metrics * about it. * Note that to find out if hint has been used is libstdc++ * implementation dependent. */ bool _M_hint_used(_Base_const_iterator __hint, _Base_iterator __res) { return (__hint == __res || (__hint == _M_base().end() && ++__res == _M_base().end()) || (__hint != _M_base().end() && (++__hint == __res || ++__res == --__hint))); } template friend bool operator==(const map<_K1, _T1, _C1, _A1>&, const map<_K1, _T1, _C1, _A1>&); template friend bool operator<(const map<_K1, _T1, _C1, _A1>&, const map<_K1, _T1, _C1, _A1>&); }; template inline bool operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() == __rhs._M_base(); } template inline bool operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { __profcxx_map2umap_invalidate(__lhs._M_map2umap_info); __profcxx_map2umap_invalidate(__rhs._M_map2umap_info); return __lhs._M_base() < __rhs._M_base(); } template inline bool operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__lhs == __rhs); } template inline bool operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__rhs < __lhs); } template inline bool operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { return !(__lhs < __rhs); } template inline bool operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, const map<_Key, _Tp, _Compare, _Allocator>& __rhs) { return __rhs < __lhs; } template inline void swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs, map<_Key, _Tp, _Compare, _Allocator>& __rhs) _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } } // namespace __profile } // namespace std #endif c++/8/ios000064400000003101152640040230005767 0ustar00// Iostreams base classes -*- C++ -*- // Copyright (C) 1997-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/ios * This is a Standard C++ Library header. */ // // ISO C++ 14882: 27.4 Iostreams base classes // #ifndef _GLIBCXX_IOS #define _GLIBCXX_IOS 1 #pragma GCC system_header #include #include // For ios_base::failure #include // For char_traits, streamoff, streamsize, fpos #include // For class locale #include // For ios_base declarations. #include #include #endif /* _GLIBCXX_IOS */ c++/8/sstream000064400000064367152640040230006700 0ustar00// String based streams -*- C++ -*- // Copyright (C) 1997-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/sstream * This is a Standard C++ Library header. */ // // ISO C++ 14882: 27.7 String-based streams // #ifndef _GLIBCXX_SSTREAM #define _GLIBCXX_SSTREAM 1 #pragma GCC system_header #include #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_CXX11 // [27.7.1] template class basic_stringbuf /** * @brief The actual work of input and output (for std::string). * @ingroup io * * @tparam _CharT Type of character stream. * @tparam _Traits Traits for character type, defaults to * char_traits<_CharT>. * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. * * This class associates either or both of its input and output sequences * with a sequence of characters, which can be initialized from, or made * available as, a @c std::basic_string. (Paraphrased from [27.7.1]/1.) * * For this class, open modes (of type @c ios_base::openmode) have * @c in set if the input sequence can be read, and @c out set if the * output sequence can be written. */ template class basic_stringbuf : public basic_streambuf<_CharT, _Traits> { struct __xfer_bufptrs; public: // Types: typedef _CharT char_type; typedef _Traits traits_type; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 251. basic_stringbuf missing allocator_type typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_streambuf __streambuf_type; typedef basic_string __string_type; typedef typename __string_type::size_type __size_type; protected: /// Place to stash in || out || in | out settings for current stringbuf. ios_base::openmode _M_mode; // Data Members: __string_type _M_string; public: // Constructors: /** * @brief Starts with an empty string buffer. * @param __mode Whether the buffer can read, or write, or both. * * The default constructor initializes the parent class using its * own default ctor. */ explicit basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out) : __streambuf_type(), _M_mode(__mode), _M_string() { } /** * @brief Starts with an existing string buffer. * @param __str A string to copy as a starting buffer. * @param __mode Whether the buffer can read, or write, or both. * * This constructor initializes the parent class using its * own default ctor. */ explicit basic_stringbuf(const __string_type& __str, ios_base::openmode __mode = ios_base::in | ios_base::out) : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size(), __str.get_allocator()) { _M_stringbuf_init(__mode); } #if __cplusplus >= 201103L basic_stringbuf(const basic_stringbuf&) = delete; basic_stringbuf(basic_stringbuf&& __rhs) : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this)) { __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); } // 27.8.2.2 Assign and swap: basic_stringbuf& operator=(const basic_stringbuf&) = delete; basic_stringbuf& operator=(basic_stringbuf&& __rhs) { __xfer_bufptrs __st{__rhs, this}; const __streambuf_type& __base = __rhs; __streambuf_type::operator=(__base); this->pubimbue(__rhs.getloc()); _M_mode = __rhs._M_mode; _M_string = std::move(__rhs._M_string); __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); return *this; } void swap(basic_stringbuf& __rhs) { __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)}; __xfer_bufptrs __r_st{__rhs, this}; __streambuf_type& __base = __rhs; __streambuf_type::swap(__base); __rhs.pubimbue(this->pubimbue(__rhs.getloc())); std::swap(_M_mode, __rhs._M_mode); std::swap(_M_string, __rhs._M_string); } #endif // Get and set: /** * @brief Copying out the string buffer. * @return A copy of one of the underlying sequences. * * If the buffer is only created in input mode, the underlying * character sequence is equal to the input sequence; otherwise, it * is equal to the output sequence. [27.7.1.2]/1 */ __string_type str() const { __string_type __ret(_M_string.get_allocator()); if (this->pptr()) { // The current egptr() may not be the actual string end. if (this->pptr() > this->egptr()) __ret.assign(this->pbase(), this->pptr()); else __ret.assign(this->pbase(), this->egptr()); } else __ret = _M_string; return __ret; } /** * @brief Setting a new buffer. * @param __s The string to use as a new sequence. * * Deallocates any previous stored sequence, then copies @a s to * use as a new one. */ void str(const __string_type& __s) { // Cannot use _M_string = __s, since v3 strings are COW // (not always true now but assign() always works). _M_string.assign(__s.data(), __s.size()); _M_stringbuf_init(_M_mode); } protected: // Common initialization code goes here. void _M_stringbuf_init(ios_base::openmode __mode) { _M_mode = __mode; __size_type __len = 0; if (_M_mode & (ios_base::ate | ios_base::app)) __len = _M_string.size(); _M_sync(const_cast(_M_string.data()), 0, __len); } virtual streamsize showmanyc() { streamsize __ret = -1; if (_M_mode & ios_base::in) { _M_update_egptr(); __ret = this->egptr() - this->gptr(); } return __ret; } virtual int_type underflow(); virtual int_type pbackfail(int_type __c = traits_type::eof()); virtual int_type overflow(int_type __c = traits_type::eof()); /** * @brief Manipulates the buffer. * @param __s Pointer to a buffer area. * @param __n Size of @a __s. * @return @c this * * If no buffer has already been created, and both @a __s and @a __n are * non-zero, then @c __s is used as a buffer; see * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering * for more. */ virtual __streambuf_type* setbuf(char_type* __s, streamsize __n) { if (__s && __n >= 0) { // This is implementation-defined behavior, and assumes // that an external char_type array of length __n exists // and has been pre-allocated. If this is not the case, // things will quickly blow up. // Step 1: Destroy the current internal array. _M_string.clear(); // Step 2: Use the external array. _M_sync(__s, __n, 0); } return this; } virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out); // Internal function for correctly updating the internal buffer // for a particular _M_string, due to initialization or re-sizing // of an existing _M_string. void _M_sync(char_type* __base, __size_type __i, __size_type __o); // Internal function for correctly updating egptr() to the actual // string end. void _M_update_egptr() { const bool __testin = _M_mode & ios_base::in; if (this->pptr() && this->pptr() > this->egptr()) { if (__testin) this->setg(this->eback(), this->gptr(), this->pptr()); else this->setg(this->pptr(), this->pptr(), this->pptr()); } } // Works around the issue with pbump, part of the protected // interface of basic_streambuf, taking just an int. void _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); private: #if __cplusplus >= 201103L #if _GLIBCXX_USE_CXX11_ABI // This type captures the state of the gptr / pptr pointers as offsets // so they can be restored in another object after moving the string. struct __xfer_bufptrs { __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to) : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1} { const _CharT* const __str = __from._M_string.data(); const _CharT* __end = nullptr; if (__from.eback()) { _M_goff[0] = __from.eback() - __str; _M_goff[1] = __from.gptr() - __str; _M_goff[2] = __from.egptr() - __str; __end = __from.egptr(); } if (__from.pbase()) { _M_poff[0] = __from.pbase() - __str; _M_poff[1] = __from.pptr() - __from.pbase(); _M_poff[2] = __from.epptr() - __str; if (__from.pptr() > __end) __end = __from.pptr(); } // Set _M_string length to the greater of the get and put areas. if (__end) { // The const_cast avoids changing this constructor's signature, // because it is exported from the dynamic library. auto& __mut_from = const_cast(__from); __mut_from._M_string._M_length(__end - __str); } } ~__xfer_bufptrs() { char_type* __str = const_cast(_M_to->_M_string.data()); if (_M_goff[0] != -1) _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]); if (_M_poff[0] != -1) _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]); } basic_stringbuf* _M_to; off_type _M_goff[3]; off_type _M_poff[3]; }; #else // This type does nothing when using Copy-On-Write strings. struct __xfer_bufptrs { __xfer_bufptrs(const basic_stringbuf&, basic_stringbuf*) { } }; #endif // The move constructor initializes an __xfer_bufptrs temporary then // delegates to this constructor to performs moves during its lifetime. basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&) : __streambuf_type(static_cast(__rhs)), _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string)) { } #endif }; // [27.7.2] Template class basic_istringstream /** * @brief Controlling input for std::string. * @ingroup io * * @tparam _CharT Type of character stream. * @tparam _Traits Traits for character type, defaults to * char_traits<_CharT>. * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. * * This class supports reading from objects of type std::basic_string, * using the inherited functions from std::basic_istream. To control * the associated sequence, an instance of std::basic_stringbuf is used, * which this page refers to as @c sb. */ template class basic_istringstream : public basic_istream<_CharT, _Traits> { public: // Types: typedef _CharT char_type; typedef _Traits traits_type; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 251. basic_stringbuf missing allocator_type typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; // Non-standard types: typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_istream __istream_type; private: __stringbuf_type _M_stringbuf; public: // Constructors: /** * @brief Default constructor starts with an empty string buffer. * @param __mode Whether the buffer can read, or write, or both. * * @c ios_base::in is automatically included in @a __mode. * * Initializes @c sb using @c __mode|in, and passes @c &sb to the base * class initializer. Does not allocate any buffer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_istringstream(ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_stringbuf(__mode | ios_base::in) { this->init(&_M_stringbuf); } /** * @brief Starts with an existing string buffer. * @param __str A string to copy as a starting buffer. * @param __mode Whether the buffer can read, or write, or both. * * @c ios_base::in is automatically included in @a mode. * * Initializes @c sb using @a str and @c mode|in, and passes @c &sb * to the base class initializer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_istringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) { this->init(&_M_stringbuf); } /** * @brief The destructor does nothing. * * The buffer is deallocated by the stringbuf object, not the * formatting stream. */ ~basic_istringstream() { } #if __cplusplus >= 201103L basic_istringstream(const basic_istringstream&) = delete; basic_istringstream(basic_istringstream&& __rhs) : __istream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __istream_type::set_rdbuf(&_M_stringbuf); } // 27.8.3.2 Assign and swap: basic_istringstream& operator=(const basic_istringstream&) = delete; basic_istringstream& operator=(basic_istringstream&& __rhs) { __istream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_istringstream& __rhs) { __istream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } #endif // Members: /** * @brief Accessing the underlying buffer. * @return The current basic_stringbuf buffer. * * This hides both signatures of std::basic_ios::rdbuf(). */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } /** * @brief Copying out the string buffer. * @return @c rdbuf()->str() */ __string_type str() const { return _M_stringbuf.str(); } /** * @brief Setting a new buffer. * @param __s The string to use as a new sequence. * * Calls @c rdbuf()->str(s). */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; // [27.7.3] Template class basic_ostringstream /** * @brief Controlling output for std::string. * @ingroup io * * @tparam _CharT Type of character stream. * @tparam _Traits Traits for character type, defaults to * char_traits<_CharT>. * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. * * This class supports writing to objects of type std::basic_string, * using the inherited functions from std::basic_ostream. To control * the associated sequence, an instance of std::basic_stringbuf is used, * which this page refers to as @c sb. */ template class basic_ostringstream : public basic_ostream<_CharT, _Traits> { public: // Types: typedef _CharT char_type; typedef _Traits traits_type; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 251. basic_stringbuf missing allocator_type typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; // Non-standard types: typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_ostream __ostream_type; private: __stringbuf_type _M_stringbuf; public: // Constructors/destructor: /** * @brief Default constructor starts with an empty string buffer. * @param __mode Whether the buffer can read, or write, or both. * * @c ios_base::out is automatically included in @a mode. * * Initializes @c sb using @c mode|out, and passes @c &sb to the base * class initializer. Does not allocate any buffer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_ostringstream(ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_stringbuf(__mode | ios_base::out) { this->init(&_M_stringbuf); } /** * @brief Starts with an existing string buffer. * @param __str A string to copy as a starting buffer. * @param __mode Whether the buffer can read, or write, or both. * * @c ios_base::out is automatically included in @a mode. * * Initializes @c sb using @a str and @c mode|out, and passes @c &sb * to the base class initializer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_ostringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) { this->init(&_M_stringbuf); } /** * @brief The destructor does nothing. * * The buffer is deallocated by the stringbuf object, not the * formatting stream. */ ~basic_ostringstream() { } #if __cplusplus >= 201103L basic_ostringstream(const basic_ostringstream&) = delete; basic_ostringstream(basic_ostringstream&& __rhs) : __ostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __ostream_type::set_rdbuf(&_M_stringbuf); } // 27.8.3.2 Assign and swap: basic_ostringstream& operator=(const basic_ostringstream&) = delete; basic_ostringstream& operator=(basic_ostringstream&& __rhs) { __ostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_ostringstream& __rhs) { __ostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } #endif // Members: /** * @brief Accessing the underlying buffer. * @return The current basic_stringbuf buffer. * * This hides both signatures of std::basic_ios::rdbuf(). */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } /** * @brief Copying out the string buffer. * @return @c rdbuf()->str() */ __string_type str() const { return _M_stringbuf.str(); } /** * @brief Setting a new buffer. * @param __s The string to use as a new sequence. * * Calls @c rdbuf()->str(s). */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; // [27.7.4] Template class basic_stringstream /** * @brief Controlling input and output for std::string. * @ingroup io * * @tparam _CharT Type of character stream. * @tparam _Traits Traits for character type, defaults to * char_traits<_CharT>. * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. * * This class supports reading from and writing to objects of type * std::basic_string, using the inherited functions from * std::basic_iostream. To control the associated sequence, an instance * of std::basic_stringbuf is used, which this page refers to as @c sb. */ template class basic_stringstream : public basic_iostream<_CharT, _Traits> { public: // Types: typedef _CharT char_type; typedef _Traits traits_type; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 251. basic_stringbuf missing allocator_type typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; // Non-standard Types: typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_iostream __iostream_type; private: __stringbuf_type _M_stringbuf; public: // Constructors/destructors /** * @brief Default constructor starts with an empty string buffer. * @param __m Whether the buffer can read, or write, or both. * * Initializes @c sb using the mode from @c __m, and passes @c * &sb to the base class initializer. Does not allocate any * buffer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(), _M_stringbuf(__m) { this->init(&_M_stringbuf); } /** * @brief Starts with an existing string buffer. * @param __str A string to copy as a starting buffer. * @param __m Whether the buffer can read, or write, or both. * * Initializes @c sb using @a __str and @c __m, and passes @c &sb * to the base class initializer. * * That's a lie. We initialize the base class with NULL, because the * string class does its own memory management. */ explicit basic_stringstream(const __string_type& __str, ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(), _M_stringbuf(__str, __m) { this->init(&_M_stringbuf); } /** * @brief The destructor does nothing. * * The buffer is deallocated by the stringbuf object, not the * formatting stream. */ ~basic_stringstream() { } #if __cplusplus >= 201103L basic_stringstream(const basic_stringstream&) = delete; basic_stringstream(basic_stringstream&& __rhs) : __iostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __iostream_type::set_rdbuf(&_M_stringbuf); } // 27.8.3.2 Assign and swap: basic_stringstream& operator=(const basic_stringstream&) = delete; basic_stringstream& operator=(basic_stringstream&& __rhs) { __iostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_stringstream& __rhs) { __iostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } #endif // Members: /** * @brief Accessing the underlying buffer. * @return The current basic_stringbuf buffer. * * This hides both signatures of std::basic_ios::rdbuf(). */ __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } /** * @brief Copying out the string buffer. * @return @c rdbuf()->str() */ __string_type str() const { return _M_stringbuf.str(); } /** * @brief Setting a new buffer. * @param __s The string to use as a new sequence. * * Calls @c rdbuf()->str(s). */ void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; #if __cplusplus >= 201103L /// Swap specialization for stringbufs. template inline void swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } /// Swap specialization for istringstreams. template inline void swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, basic_istringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } /// Swap specialization for ostringstreams. template inline void swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, basic_ostringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } /// Swap specialization for stringstreams. template inline void swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, basic_stringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } #endif _GLIBCXX_END_NAMESPACE_CXX11 _GLIBCXX_END_NAMESPACE_VERSION } // namespace #include #endif /* _GLIBCXX_SSTREAM */ c++/8/functional000064400000111566152640040230007356 0ustar00// -*- C++ -*- // Copyright (C) 2001-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * Copyright (c) 1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * */ /** @file include/functional * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_FUNCTIONAL #define _GLIBCXX_FUNCTIONAL 1 #pragma GCC system_header #include #include #if __cplusplus >= 201103L #include #include #include #include #include #include // std::reference_wrapper and _Mem_fn_traits #include // std::function #if __cplusplus > 201402L # include # include # include # include # include #endif namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION #if __cplusplus > 201402L # define __cpp_lib_invoke 201411 /// Invoke a callable object. template inline invoke_result_t<_Callable, _Args...> invoke(_Callable&& __fn, _Args&&... __args) noexcept(is_nothrow_invocable_v<_Callable, _Args...>) { return std::__invoke(std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } #endif template::value> class _Mem_fn_base : public _Mem_fn_traits<_MemFunPtr>::__maybe_type { using _Traits = _Mem_fn_traits<_MemFunPtr>; using _Arity = typename _Traits::__arity; using _Varargs = typename _Traits::__vararg; template friend struct _Bind_check_arity; _MemFunPtr _M_pmf; public: using result_type = typename _Traits::__result_type; explicit constexpr _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { } template auto operator()(_Args&&... __args) const noexcept(noexcept( std::__invoke(_M_pmf, std::forward<_Args>(__args)...))) -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...)) { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); } }; // Partial specialization for member object pointers. template class _Mem_fn_base<_MemObjPtr, false> { using _Arity = integral_constant; using _Varargs = false_type; template friend struct _Bind_check_arity; _MemObjPtr _M_pm; public: explicit constexpr _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { } template auto operator()(_Tp&& __obj) const noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))) -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj))) { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); } }; template struct _Mem_fn; // undefined template struct _Mem_fn<_Res _Class::*> : _Mem_fn_base<_Res _Class::*> { using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base; }; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2048. Unnecessary mem_fn overloads /** * @brief Returns a function object that forwards to the member * pointer @a pm. * @ingroup functors */ template inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::* __pm) noexcept { return _Mem_fn<_Tp _Class::*>(__pm); } /** * @brief Determines if the given type _Tp is a function object that * should be treated as a subexpression when evaluating calls to * function objects returned by bind(). * * C++11 [func.bind.isbind]. * @ingroup binders */ template struct is_bind_expression : public false_type { }; /** * @brief Determines if the given type _Tp is a placeholder in a * bind() expression and, if so, which placeholder it is. * * C++11 [func.bind.isplace]. * @ingroup binders */ template struct is_placeholder : public integral_constant { }; #if __cplusplus > 201402L template inline constexpr bool is_bind_expression_v = is_bind_expression<_Tp>::value; template inline constexpr int is_placeholder_v = is_placeholder<_Tp>::value; #endif // C++17 /** @brief The type of placeholder objects defined by libstdc++. * @ingroup binders */ template struct _Placeholder { }; /** @namespace std::placeholders * @brief ISO C++11 entities sub-namespace for functional. * @ingroup binders */ namespace placeholders { /* Define a large number of placeholders. There is no way to * simplify this with variadic templates, because we're introducing * unique names for each. */ extern const _Placeholder<1> _1; extern const _Placeholder<2> _2; extern const _Placeholder<3> _3; extern const _Placeholder<4> _4; extern const _Placeholder<5> _5; extern const _Placeholder<6> _6; extern const _Placeholder<7> _7; extern const _Placeholder<8> _8; extern const _Placeholder<9> _9; extern const _Placeholder<10> _10; extern const _Placeholder<11> _11; extern const _Placeholder<12> _12; extern const _Placeholder<13> _13; extern const _Placeholder<14> _14; extern const _Placeholder<15> _15; extern const _Placeholder<16> _16; extern const _Placeholder<17> _17; extern const _Placeholder<18> _18; extern const _Placeholder<19> _19; extern const _Placeholder<20> _20; extern const _Placeholder<21> _21; extern const _Placeholder<22> _22; extern const _Placeholder<23> _23; extern const _Placeholder<24> _24; extern const _Placeholder<25> _25; extern const _Placeholder<26> _26; extern const _Placeholder<27> _27; extern const _Placeholder<28> _28; extern const _Placeholder<29> _29; } /** * Partial specialization of is_placeholder that provides the placeholder * number for the placeholder objects defined by libstdc++. * @ingroup binders */ template struct is_placeholder<_Placeholder<_Num> > : public integral_constant { }; template struct is_placeholder > : public integral_constant { }; // Like tuple_element_t but SFINAE-friendly. template using _Safe_tuple_element_t = typename enable_if<(__i < tuple_size<_Tuple>::value), tuple_element<__i, _Tuple>>::type::type; /** * Maps an argument to bind() into an actual argument to the bound * function object [func.bind.bind]/10. Only the first parameter should * be specified: the rest are used to determine among the various * implementations. Note that, although this class is a function * object, it isn't entirely normal because it takes only two * parameters regardless of the number of parameters passed to the * bind expression. The first parameter is the bound argument and * the second parameter is a tuple containing references to the * rest of the arguments. */ template::value, bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> class _Mu; /** * If the argument is reference_wrapper<_Tp>, returns the * underlying reference. * C++11 [func.bind.bind] p10 bullet 1. */ template class _Mu, false, false> { public: /* Note: This won't actually work for const volatile * reference_wrappers, because reference_wrapper::get() is const * but not volatile-qualified. This might be a defect in the TR. */ template _Tp& operator()(_CVRef& __arg, _Tuple&) const volatile { return __arg.get(); } }; /** * If the argument is a bind expression, we invoke the underlying * function object with the same cv-qualifiers as we are given and * pass along all of our arguments (unwrapped). * C++11 [func.bind.bind] p10 bullet 2. */ template class _Mu<_Arg, true, false> { public: template auto operator()(_CVArg& __arg, tuple<_Args...>& __tuple) const volatile -> decltype(__arg(declval<_Args>()...)) { // Construct an index tuple and forward to __call typedef typename _Build_index_tuple::__type _Indexes; return this->__call(__arg, __tuple, _Indexes()); } private: // Invokes the underlying function object __arg by unpacking all // of the arguments in the tuple. template auto __call(_CVArg& __arg, tuple<_Args...>& __tuple, const _Index_tuple<_Indexes...>&) const volatile -> decltype(__arg(declval<_Args>()...)) { return __arg(std::get<_Indexes>(std::move(__tuple))...); } }; /** * If the argument is a placeholder for the Nth argument, returns * a reference to the Nth argument to the bind function object. * C++11 [func.bind.bind] p10 bullet 3. */ template class _Mu<_Arg, false, true> { public: template _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&& operator()(const volatile _Arg&, _Tuple& __tuple) const volatile { return ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple)); } }; /** * If the argument is just a value, returns a reference to that * value. The cv-qualifiers on the reference are determined by the caller. * C++11 [func.bind.bind] p10 bullet 4. */ template class _Mu<_Arg, false, false> { public: template _CVArg&& operator()(_CVArg&& __arg, _Tuple&) const volatile { return std::forward<_CVArg>(__arg); } }; // std::get for volatile-qualified tuples template inline auto __volget(volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } // std::get for const-volatile-qualified tuples template inline auto __volget(const volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } /// Type of the function object returned from bind(). template struct _Bind; template class _Bind<_Functor(_Bound_args...)> : public _Weak_result_type<_Functor> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // Call unqualified template _Result __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } // Call as const template _Result __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } // Call as volatile template _Result __call_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } // Call as const volatile template _Result __call_c_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } template using _Mu_type = decltype( _Mu::type>()( std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) ); template using _Res_type_impl = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type; template using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>; template using __dependent = typename enable_if::value+1), _Functor>::type; template class __cv_quals> using _Res_type_cv = _Res_type_impl< typename __cv_quals<__dependent<_CallArgs>>::type, _CallArgs, typename __cv_quals<_Bound_args>::type...>; public: template explicit _Bind(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit _Bind(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind(const _Bind&) = default; _Bind(_Bind&& __b) : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) { } // Call unqualified template>> _Result operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } // Call as const template, add_const>> _Result operator()(_Args&&... __args) const { return this->__call_c<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } #if __cplusplus > 201402L # define _GLIBCXX_DEPR_BIND \ [[deprecated("std::bind does not support volatile in C++17")]] #else # define _GLIBCXX_DEPR_BIND #endif // Call as volatile template, add_volatile>> _GLIBCXX_DEPR_BIND _Result operator()(_Args&&... __args) volatile { return this->__call_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } // Call as const volatile template, add_cv>> _GLIBCXX_DEPR_BIND _Result operator()(_Args&&... __args) const volatile { return this->__call_c_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; /// Type of the function object returned from bind(). template struct _Bind_result; template class _Bind_result<_Result, _Functor(_Bound_args...)> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // sfinae types template using __enable_if_void = typename enable_if{}>::type; template using __disable_if_void = typename enable_if{}, _Result>::type; // Call unqualified template __disable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } // Call unqualified, return void template __enable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { std::__invoke(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } // Call as const template __disable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } // Call as const, return void template __enable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { std::__invoke(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } // Call as volatile template __disable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } // Call as volatile, return void template __enable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { std::__invoke(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } // Call as const volatile template __disable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } // Call as const volatile, return void template __enable_if_void<_Res> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { std::__invoke(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } public: typedef _Result result_type; template explicit _Bind_result(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit _Bind_result(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind_result(const _Bind_result&) = default; _Bind_result(_Bind_result&& __b) : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args)) { } // Call unqualified template result_type operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } // Call as const template result_type operator()(_Args&&... __args) const { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } // Call as volatile template _GLIBCXX_DEPR_BIND result_type operator()(_Args&&... __args) volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } // Call as const volatile template _GLIBCXX_DEPR_BIND result_type operator()(_Args&&... __args) const volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; #undef _GLIBCXX_DEPR_BIND /** * @brief Class template _Bind is always a bind expression. * @ingroup binders */ template struct is_bind_expression<_Bind<_Signature> > : public true_type { }; /** * @brief Class template _Bind is always a bind expression. * @ingroup binders */ template struct is_bind_expression > : public true_type { }; /** * @brief Class template _Bind is always a bind expression. * @ingroup binders */ template struct is_bind_expression > : public true_type { }; /** * @brief Class template _Bind is always a bind expression. * @ingroup binders */ template struct is_bind_expression> : public true_type { }; /** * @brief Class template _Bind_result is always a bind expression. * @ingroup binders */ template struct is_bind_expression<_Bind_result<_Result, _Signature>> : public true_type { }; /** * @brief Class template _Bind_result is always a bind expression. * @ingroup binders */ template struct is_bind_expression> : public true_type { }; /** * @brief Class template _Bind_result is always a bind expression. * @ingroup binders */ template struct is_bind_expression> : public true_type { }; /** * @brief Class template _Bind_result is always a bind expression. * @ingroup binders */ template struct is_bind_expression> : public true_type { }; template struct _Bind_check_arity { }; template struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) == sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...> { using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity; using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs; static_assert(_Varargs::value ? sizeof...(_BoundArgs) >= _Arity::value + 1 : sizeof...(_BoundArgs) == _Arity::value + 1, "Wrong number of arguments for pointer-to-member"); }; // Trait type used to remove std::bind() from overload set via SFINAE // when first argument has integer type, so that std::bind() will // not be a better match than ::bind() from the BSD Sockets API. template::type> using __is_socketlike = __or_, is_enum<_Tp2>>; template struct _Bind_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __func_type; typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; }; // Partial specialization for is_socketlike == true, does not define // nested type so std::bind() will not participate in overload resolution // when the first argument might be a socket file descriptor. template struct _Bind_helper { }; /** * @brief Function template for std::bind. * @ingroup binders */ template inline typename _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bind_helper __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } template struct _Bindres_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __functor_type; typedef _Bind_result<_Result, __functor_type(typename decay<_BoundArgs>::type...)> type; }; /** * @brief Function template for std::bind. * @ingroup binders */ template inline typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } #if __cplusplus >= 201402L /// Generalized negator. template class _Not_fn { template using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type; template static decltype(!std::declval<_Tp>()) _S_not() noexcept(noexcept(!std::declval<_Tp>())); public: template _Not_fn(_Fn2&& __fn, int) : _M_fn(std::forward<_Fn2>(__fn)) { } _Not_fn(const _Not_fn& __fn) = default; _Not_fn(_Not_fn&& __fn) = default; ~_Not_fn() = default; // Macro to define operator() with given cv-qualifiers ref-qualifiers, // forwarding _M_fn and the function arguments with the same qualifiers, // and deducing the return type and exception-specification. #define _GLIBCXX_NOT_FN_CALL_OP( _QUALS ) \ template \ decltype(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>()) \ operator()(_Args&&... __args) _QUALS \ noexcept(__is_nothrow_invocable<_Fn _QUALS, _Args...>::value \ && noexcept(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>())) \ { \ return !std::__invoke(std::forward< _Fn _QUALS >(_M_fn), \ std::forward<_Args>(__args)...); \ } _GLIBCXX_NOT_FN_CALL_OP( & ) _GLIBCXX_NOT_FN_CALL_OP( const & ) _GLIBCXX_NOT_FN_CALL_OP( && ) _GLIBCXX_NOT_FN_CALL_OP( const && ) #undef _GLIBCXX_NOT_FN_CALL private: _Fn _M_fn; }; template struct __is_byte_like : false_type { }; template struct __is_byte_like<_Tp, equal_to<_Tp>> : __bool_constant::value> { }; template struct __is_byte_like<_Tp, equal_to> : __bool_constant::value> { }; #if __cplusplus >= 201703L // Declare std::byte (full definition is in ). enum class byte : unsigned char; template<> struct __is_byte_like> : true_type { }; template<> struct __is_byte_like> : true_type { }; #define __cpp_lib_not_fn 201603 /// [func.not_fn] Function template not_fn template inline auto not_fn(_Fn&& __fn) noexcept(std::is_nothrow_constructible, _Fn&&>::value) { return _Not_fn>{std::forward<_Fn>(__fn), 0}; } // Searchers #define __cpp_lib_boyer_moore_searcher 201603 template> class default_searcher { public: default_searcher(_ForwardIterator1 __pat_first, _ForwardIterator1 __pat_last, _BinaryPredicate __pred = _BinaryPredicate()) : _M_m(__pat_first, __pat_last, std::move(__pred)) { } template pair<_ForwardIterator2, _ForwardIterator2> operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const { _ForwardIterator2 __first_ret = std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m), std::get<2>(_M_m)); auto __ret = std::make_pair(__first_ret, __first_ret); if (__ret.first != __last) std::advance(__ret.second, std::distance(std::get<0>(_M_m), std::get<1>(_M_m))); return __ret; } private: tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m; }; template struct __boyer_moore_map_base { template __boyer_moore_map_base(_RAIter __pat, size_t __patlen, _Hash&& __hf, _Pred&& __pred) : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) } { if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) _M_bad_char[__pat[__i]] = __patlen - 1 - __i; } using __diff_type = _Tp; __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __iter = _M_bad_char.find(__key); if (__iter == _M_bad_char.end()) return __not_found; return __iter->second; } _Pred _M_pred() const { return _M_bad_char.key_eq(); } _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char; }; template struct __boyer_moore_array_base { template __boyer_moore_array_base(_RAIter __pat, size_t __patlen, _Unused&&, _Pred&& __pred) : _M_bad_char{ _GLIBCXX_STD_C::array<_Tp, _Len>{}, std::move(__pred) } { std::get<0>(_M_bad_char).fill(__patlen); if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) { auto __ch = __pat[__i]; using _UCh = make_unsigned_t; auto __uch = static_cast<_UCh>(__ch); std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i; } } using __diff_type = _Tp; template __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __ukey = static_cast>(__key); if (__ukey >= _Len) return __not_found; return std::get<0>(_M_bad_char)[__ukey]; } const _Pred& _M_pred() const { return std::get<1>(_M_bad_char); } tuple<_GLIBCXX_STD_C::array<_Tp, _Len>, _Pred> _M_bad_char; }; // Use __boyer_moore_array_base when pattern consists of narrow characters // (or std::byte) and uses std::equal_to as the predicate. template::value_type, typename _Diff = typename iterator_traits<_RAIter>::difference_type> using __boyer_moore_base_t = conditional_t<__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()); template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const; private: bool _M_is_prefix(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __suffixlen = __len - __pos; for (__diff_type __i = 0; __i < __suffixlen; ++__i) if (!__pred(__word[__i], __word[__pos + __i])) return false; return true; } __diff_type _M_suffix_length(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __i = 0; while (__pred(__word[__pos - __i], __word[__len - 1 - __i]) && __i < __pos) { ++__i; } return __i; } template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; _GLIBCXX_STD_C::vector<__diff_type> _M_good_suffix; }; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_horspool_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end) { } template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { const auto& __pred = this->_M_pred(); auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); auto __len = __last - __first; while (__len >= __patlen) { for (auto __scan = __patlen - 1; __pred(__first[__scan], _M_pat[__scan]); --__scan) if (__scan == 0) return std::make_pair(__first, __first + __patlen); auto __shift = _M_bad_char_shift(__first[__patlen - 1]); __len -= __shift; __first += __shift; } return std::make_pair(__last, __last); } private: template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; }; template boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf, _BinaryPredicate __pred) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat) { auto __patlen = __pat_end - __pat; if (__patlen == 0) return; __diff_type __last_prefix = __patlen - 1; for (__diff_type __p = __patlen - 1; __p >= 0; --__p) { if (_M_is_prefix(__pat, __patlen, __p + 1)) __last_prefix = __p + 1; _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p); } for (__diff_type __p = 0; __p < __patlen - 1; ++__p) { auto __slen = _M_suffix_length(__pat, __patlen, __p); auto __pos = __patlen - 1 - __slen; if (!__pred(__pat[__p - __slen], __pat[__pos])) _M_good_suffix[__pos] = __patlen - 1 - __p + __slen; } } template template pair<_RandomAccessIterator2, _RandomAccessIterator2> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); const auto& __pred = this->_M_pred(); __diff_type __i = __patlen - 1; auto __stringlen = __last - __first; while (__i < __stringlen) { __diff_type __j = __patlen - 1; while (__j >= 0 && __pred(__first[__i], _M_pat[__j])) { --__i; --__j; } if (__j < 0) { const auto __match = __first + __i + 1; return std::make_pair(__match, __match + __patlen); } __i += std::max(_M_bad_char_shift(__first[__i]), _M_good_suffix[__j]); } return std::make_pair(__last, __last); } #endif // C++17 #endif // C++14 _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++11 #endif // _GLIBCXX_FUNCTIONAL c++/8/unordered_map000064400000003470152640040230010032 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/unordered_map * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_UNORDERED_MAP #define _GLIBCXX_UNORDERED_MAP 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include #include #include #include #include #include // equal_to, _Identity, _Select1st #include #include #include #include #ifdef _GLIBCXX_DEBUG # include #endif #ifdef _GLIBCXX_PROFILE # include #endif #endif // C++11 #endif // _GLIBCXX_UNORDERED_MAP c++/8/list000064400000005042152640040230006156 0ustar00// -*- C++ -*- // Copyright (C) 2001-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1996,1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /** @file include/list * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_LIST #define _GLIBCXX_LIST 1 #pragma GCC system_header #include #include #include #include #include #ifdef _GLIBCXX_DEBUG # include #endif #ifdef _GLIBCXX_PROFILE # include #endif #endif /* _GLIBCXX_LIST */ c++/8/bitset000064400000131526152640040230006504 0ustar00// -*- C++ -*- // Copyright (C) 2001-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * Copyright (c) 1998 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /** @file include/bitset * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_BITSET #define _GLIBCXX_BITSET 1 #pragma GCC system_header #include #include // For invalid_argument, out_of_range, // overflow_error #include #include #if __cplusplus >= 201103L # include #endif #define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * __SIZEOF_LONG__) #define _GLIBCXX_BITSET_WORDS(__n) \ ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \ ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1)) #define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__) namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_CONTAINER /** * Base class, general case. It is a class invariant that _Nw will be * nonnegative. * * See documentation for bitset. */ template struct _Base_bitset { typedef unsigned long _WordT; /// 0 is the least significant word. _WordT _M_w[_Nw]; _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT : _M_w() { } #if __cplusplus >= 201103L constexpr _Base_bitset(unsigned long long __val) noexcept : _M_w{ _WordT(__val) #if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__ , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD) #endif } { } #else _Base_bitset(unsigned long __val) : _M_w() { _M_w[0] = __val; } #endif static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t __pos) _GLIBCXX_NOEXCEPT { return _M_w[_S_whichword(__pos)]; } _GLIBCXX_CONSTEXPR _WordT _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT { return _M_w[_S_whichword(__pos)]; } #if __cplusplus >= 201103L const _WordT* _M_getdata() const noexcept { return _M_w; } #endif _WordT& _M_hiword() _GLIBCXX_NOEXCEPT { return _M_w[_Nw - 1]; } _GLIBCXX_CONSTEXPR _WordT _M_hiword() const _GLIBCXX_NOEXCEPT { return _M_w[_Nw - 1]; } void _M_do_and(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] &= __x._M_w[__i]; } void _M_do_or(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] |= __x._M_w[__i]; } void _M_do_xor(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] ^= __x._M_w[__i]; } void _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT; void _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT; void _M_do_flip() _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~_M_w[__i]; } void _M_do_set() _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~static_cast<_WordT>(0); } void _M_do_reset() _GLIBCXX_NOEXCEPT { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); } bool _M_is_equal(const _Base_bitset<_Nw>& __x) const _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; ++__i) if (_M_w[__i] != __x._M_w[__i]) return false; return true; } template bool _M_are_all() const _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw - 1; __i++) if (_M_w[__i] != ~static_cast<_WordT>(0)) return false; return _M_hiword() == (~static_cast<_WordT>(0) >> (_Nw * _GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); } bool _M_is_any() const _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) if (_M_w[__i] != static_cast<_WordT>(0)) return true; return false; } size_t _M_do_count() const _GLIBCXX_NOEXCEPT { size_t __result = 0; for (size_t __i = 0; __i < _Nw; __i++) __result += __builtin_popcountl(_M_w[__i]); return __result; } unsigned long _M_do_to_ulong() const; #if __cplusplus >= 201103L unsigned long long _M_do_to_ullong() const; #endif // find first "on" bit size_t _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT; // find the next "on" bit that follows "prev" size_t _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT; }; // Definitions of non-inline functions from _Base_bitset. template void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; if (__offset == 0) for (size_t __n = _Nw - 1; __n >= __wshift; --__n) _M_w[__n] = _M_w[__n - __wshift]; else { const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD - __offset); for (size_t __n = _Nw - 1; __n > __wshift; --__n) _M_w[__n] = ((_M_w[__n - __wshift] << __offset) | (_M_w[__n - __wshift - 1] >> __sub_offset)); _M_w[__wshift] = _M_w[0] << __offset; } std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); } } template void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; const size_t __limit = _Nw - __wshift - 1; if (__offset == 0) for (size_t __n = 0; __n <= __limit; ++__n) _M_w[__n] = _M_w[__n + __wshift]; else { const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD - __offset); for (size_t __n = 0; __n < __limit; ++__n) _M_w[__n] = ((_M_w[__n + __wshift] >> __offset) | (_M_w[__n + __wshift + 1] << __sub_offset)); _M_w[__limit] = _M_w[_Nw-1] >> __offset; } std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); } } template unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const { for (size_t __i = 1; __i < _Nw; ++__i) if (_M_w[__i]) __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong")); return _M_w[0]; } #if __cplusplus >= 201103L template unsigned long long _Base_bitset<_Nw>::_M_do_to_ullong() const { const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long); for (size_t __i = 1 + __dw; __i < _Nw; ++__i) if (_M_w[__i]) __throw_overflow_error(__N("_Base_bitset::_M_do_to_ullong")); if (__dw) return _M_w[0] + (static_cast(_M_w[1]) << _GLIBCXX_BITSET_BITS_PER_WORD); return _M_w[0]; } #endif template size_t _Base_bitset<_Nw>:: _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT { for (size_t __i = 0; __i < _Nw; __i++) { _WordT __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + __builtin_ctzl(__thisword)); } // not found, so return an indication of failure. return __not_found; } template size_t _Base_bitset<_Nw>:: _M_do_find_next(size_t __prev, size_t __not_found) const _GLIBCXX_NOEXCEPT { // make bound inclusive ++__prev; // check out of bounds if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD) return __not_found; // search first word size_t __i = _S_whichword(__prev); _WordT __thisword = _M_w[__i]; // mask off bits below bound __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if (__thisword != static_cast<_WordT>(0)) return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + __builtin_ctzl(__thisword)); // check subsequent words __i++; for (; __i < _Nw; __i++) { __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + __builtin_ctzl(__thisword)); } // not found, so return an indication of failure. return __not_found; } // end _M_do_find_next /** * Base class, specialization for a single word. * * See documentation for bitset. */ template<> struct _Base_bitset<1> { typedef unsigned long _WordT; _WordT _M_w; _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT : _M_w(0) { } #if __cplusplus >= 201103L constexpr _Base_bitset(unsigned long long __val) noexcept #else _Base_bitset(unsigned long __val) #endif : _M_w(__val) { } static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t) _GLIBCXX_NOEXCEPT { return _M_w; } _GLIBCXX_CONSTEXPR _WordT _M_getword(size_t) const _GLIBCXX_NOEXCEPT { return _M_w; } #if __cplusplus >= 201103L const _WordT* _M_getdata() const noexcept { return &_M_w; } #endif _WordT& _M_hiword() _GLIBCXX_NOEXCEPT { return _M_w; } _GLIBCXX_CONSTEXPR _WordT _M_hiword() const _GLIBCXX_NOEXCEPT { return _M_w; } void _M_do_and(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT { _M_w &= __x._M_w; } void _M_do_or(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT { _M_w |= __x._M_w; } void _M_do_xor(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT { _M_w ^= __x._M_w; } void _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT { _M_w <<= __shift; } void _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT { _M_w >>= __shift; } void _M_do_flip() _GLIBCXX_NOEXCEPT { _M_w = ~_M_w; } void _M_do_set() _GLIBCXX_NOEXCEPT { _M_w = ~static_cast<_WordT>(0); } void _M_do_reset() _GLIBCXX_NOEXCEPT { _M_w = 0; } bool _M_is_equal(const _Base_bitset<1>& __x) const _GLIBCXX_NOEXCEPT { return _M_w == __x._M_w; } template bool _M_are_all() const _GLIBCXX_NOEXCEPT { return _M_w == (~static_cast<_WordT>(0) >> (_GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); } bool _M_is_any() const _GLIBCXX_NOEXCEPT { return _M_w != 0; } size_t _M_do_count() const _GLIBCXX_NOEXCEPT { return __builtin_popcountl(_M_w); } unsigned long _M_do_to_ulong() const _GLIBCXX_NOEXCEPT { return _M_w; } #if __cplusplus >= 201103L unsigned long long _M_do_to_ullong() const noexcept { return _M_w; } #endif size_t _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT { if (_M_w != 0) return __builtin_ctzl(_M_w); else return __not_found; } // find the next "on" bit that follows "prev" size_t _M_do_find_next(size_t __prev, size_t __not_found) const _GLIBCXX_NOEXCEPT { ++__prev; if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD)) return __not_found; _WordT __x = _M_w >> __prev; if (__x != 0) return __builtin_ctzl(__x) + __prev; else return __not_found; } }; /** * Base class, specialization for no storage (zero-length %bitset). * * See documentation for bitset. */ template<> struct _Base_bitset<0> { typedef unsigned long _WordT; _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT { } #if __cplusplus >= 201103L constexpr _Base_bitset(unsigned long long) noexcept #else _Base_bitset(unsigned long) #endif { } static _GLIBCXX_CONSTEXPR size_t _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR size_t _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } static _GLIBCXX_CONSTEXPR size_t _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } static _GLIBCXX_CONSTEXPR _WordT _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } // This would normally give access to the data. The bounds-checking // in the bitset class will prevent the user from getting this far, // but (1) it must still return an lvalue to compile, and (2) the // user might call _Unchecked_set directly, in which case this /needs/ // to fail. Let's not penalize zero-length users unless they actually // make an unchecked call; all the memory ugliness is therefore // localized to this single should-never-get-this-far function. _WordT& _M_getword(size_t) _GLIBCXX_NOEXCEPT { __throw_out_of_range(__N("_Base_bitset::_M_getword")); return *new _WordT; } _GLIBCXX_CONSTEXPR _WordT _M_getword(size_t) const _GLIBCXX_NOEXCEPT { return 0; } _GLIBCXX_CONSTEXPR _WordT _M_hiword() const _GLIBCXX_NOEXCEPT { return 0; } void _M_do_and(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT { } void _M_do_or(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT { } void _M_do_xor(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT { } void _M_do_left_shift(size_t) _GLIBCXX_NOEXCEPT { } void _M_do_right_shift(size_t) _GLIBCXX_NOEXCEPT { } void _M_do_flip() _GLIBCXX_NOEXCEPT { } void _M_do_set() _GLIBCXX_NOEXCEPT { } void _M_do_reset() _GLIBCXX_NOEXCEPT { } // Are all empty bitsets equal to each other? Are they equal to // themselves? How to compare a thing which has no state? What is // the sound of one zero-length bitset clapping? bool _M_is_equal(const _Base_bitset<0>&) const _GLIBCXX_NOEXCEPT { return true; } template bool _M_are_all() const _GLIBCXX_NOEXCEPT { return true; } bool _M_is_any() const _GLIBCXX_NOEXCEPT { return false; } size_t _M_do_count() const _GLIBCXX_NOEXCEPT { return 0; } unsigned long _M_do_to_ulong() const _GLIBCXX_NOEXCEPT { return 0; } #if __cplusplus >= 201103L unsigned long long _M_do_to_ullong() const noexcept { return 0; } #endif // Normally "not found" is the size, but that could also be // misinterpreted as an index in this corner case. Oh well. size_t _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT { return 0; } size_t _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT { return 0; } }; // Helper class to zero out the unused high-order bits in the highest word. template struct _Sanitize { typedef unsigned long _WordT; static void _S_do_sanitize(_WordT& __val) _GLIBCXX_NOEXCEPT { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } }; template<> struct _Sanitize<0> { typedef unsigned long _WordT; static void _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } }; #if __cplusplus >= 201103L template struct _Sanitize_val { static constexpr unsigned long long _S_do_sanitize_val(unsigned long long __val) { return __val; } }; template struct _Sanitize_val<_Nb, true> { static constexpr unsigned long long _S_do_sanitize_val(unsigned long long __val) { return __val & ~((~static_cast(0)) << _Nb); } }; #endif /** * @brief The %bitset class represents a @e fixed-size sequence of bits. * @ingroup utilities * * (Note that %bitset does @e not meet the formal requirements of a * container. Mainly, it lacks iterators.) * * The template argument, @a Nb, may be any non-negative number, * specifying the number of bits (e.g., "0", "12", "1024*1024"). * * In the general unoptimized case, storage is allocated in word-sized * blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B * words will be used for storage. B - Nb%B bits are unused. (They are * the high-order bits in the highest word.) It is a class invariant * that those unused bits are always zero. * * If you think of %bitset as a simple array of bits, be * aware that your mental picture is reversed: a %bitset behaves * the same way as bits in integers do, with the bit at index 0 in * the least significant / right-hand position, and the bit at * index Nb-1 in the most significant / left-hand position. * Thus, unlike other containers, a %bitset's index counts from * right to left, to put it very loosely. * * This behavior is preserved when translating to and from strings. For * example, the first line of the following program probably prints * b('a') is 0001100001 on a modern ASCII system. * * @code * #include * #include * #include * * using namespace std; * * int main() * { * long a = 'a'; * bitset<10> b(a); * * cout << "b('a') is " << b << endl; * * ostringstream s; * s << b; * string str = s.str(); * cout << "index 3 in the string is " << str[3] << " but\n" * << "index 3 in the bitset is " << b[3] << endl; * } * @endcode * * Also see: * https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_containers.html * for a description of extensions. * * Most of the actual code isn't contained in %bitset<> itself, but in the * base class _Base_bitset. The base class works with whole words, not with * individual bits. This allows us to specialize _Base_bitset for the * important special case where the %bitset is only a single word. * * Extra confusion can result due to the fact that the storage for * _Base_bitset @e is a regular array, and is indexed as such. This is * carefully encapsulated. */ template class bitset : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> { private: typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base; typedef unsigned long _WordT; template void _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position) const { if (__position > __s.size()) __throw_out_of_range_fmt(__N("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)"), __position, __s.size()); } void _M_check(size_t __position, const char *__s) const { if (__position >= _Nb) __throw_out_of_range_fmt(__N("%s: __position (which is %zu) " ">= _Nb (which is %zu)"), __s, __position, _Nb); } void _M_do_sanitize() _GLIBCXX_NOEXCEPT { typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; __sanitize_type::_S_do_sanitize(this->_M_hiword()); } #if __cplusplus >= 201103L friend struct std::hash; #endif public: /** * This encapsulates the concept of a single bit. An instance of this * class is a proxy for an actual bit; this way the individual bit * operations are done as faster word-size bitwise instructions. * * Most users will never need to use this class directly; conversions * to and from bool are automatic and should be transparent. Overloaded * operators help to preserve the illusion. * * (On a typical system, this bit %reference is 64 * times the size of an actual bit. Ha.) */ class reference { friend class bitset; _WordT* _M_wp; size_t _M_bpos; // left undefined reference(); public: reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT { _M_wp = &__b._M_getword(__pos); _M_bpos = _Base::_S_whichbit(__pos); } ~reference() _GLIBCXX_NOEXCEPT { } // For b[i] = __x; reference& operator=(bool __x) _GLIBCXX_NOEXCEPT { if (__x) *_M_wp |= _Base::_S_maskbit(_M_bpos); else *_M_wp &= ~_Base::_S_maskbit(_M_bpos); return *this; } // For b[i] = b[__j]; reference& operator=(const reference& __j) _GLIBCXX_NOEXCEPT { if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) *_M_wp |= _Base::_S_maskbit(_M_bpos); else *_M_wp &= ~_Base::_S_maskbit(_M_bpos); return *this; } // Flips the bit bool operator~() const _GLIBCXX_NOEXCEPT { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } // For __x = b[i]; operator bool() const _GLIBCXX_NOEXCEPT { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } // For b[i].flip(); reference& flip() _GLIBCXX_NOEXCEPT { *_M_wp ^= _Base::_S_maskbit(_M_bpos); return *this; } }; friend class reference; // 23.3.5.1 constructors: /// All bits set to zero. _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT { } /// Initial bits bitwise-copied from a single word (others set to zero). #if __cplusplus >= 201103L constexpr bitset(unsigned long long __val) noexcept : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { } #else bitset(unsigned long __val) : _Base(__val) { _M_do_sanitize(); } #endif /** * Use a subset of a string. * @param __s A string of @a 0 and @a 1 characters. * @param __position Index of the first character in @a __s to use; * defaults to zero. * @throw std::out_of_range If @a pos is bigger the size of @a __s. * @throw std::invalid_argument If a character appears in the string * which is neither @a 0 nor @a 1. */ template explicit bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position = 0) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, std::basic_string<_CharT, _Traits, _Alloc>::npos, _CharT('0'), _CharT('1')); } /** * Use a subset of a string. * @param __s A string of @a 0 and @a 1 characters. * @param __position Index of the first character in @a __s to use. * @param __n The number of characters to copy. * @throw std::out_of_range If @a __position is bigger the size * of @a __s. * @throw std::invalid_argument If a character appears in the string * which is neither @a 0 nor @a 1. */ template bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position, size_t __n) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1')); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 396. what are characters zero and one. template bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position, size_t __n, _CharT __zero, _CharT __one = _CharT('1')) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, __n, __zero, __one); } #if __cplusplus >= 201103L /** * Construct from a character %array. * @param __str An %array of characters @a zero and @a one. * @param __n The number of characters to use. * @param __zero The character corresponding to the value 0. * @param __one The character corresponding to the value 1. * @throw std::invalid_argument If a character appears in the string * which is neither @a __zero nor @a __one. */ template explicit bitset(const _CharT* __str, typename std::basic_string<_CharT>::size_type __n = std::basic_string<_CharT>::npos, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) : _Base() { if (!__str) __throw_logic_error(__N("bitset::bitset(const _CharT*, ...)")); if (__n == std::basic_string<_CharT>::npos) __n = std::char_traits<_CharT>::length(__str); _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0, __n, __zero, __one); } #endif // 23.3.5.2 bitset operations: //@{ /** * Operations on bitsets. * @param __rhs A same-sized bitset. * * These should be self-explanatory. */ bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { this->_M_do_and(__rhs); return *this; } bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { this->_M_do_or(__rhs); return *this; } bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT { this->_M_do_xor(__rhs); return *this; } //@} //@{ /** * Operations on bitsets. * @param __position The number of places to shift. * * These should be self-explanatory. */ bitset<_Nb>& operator<<=(size_t __position) _GLIBCXX_NOEXCEPT { if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_left_shift(__position); this->_M_do_sanitize(); } else this->_M_do_reset(); return *this; } bitset<_Nb>& operator>>=(size_t __position) _GLIBCXX_NOEXCEPT { if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_right_shift(__position); this->_M_do_sanitize(); } else this->_M_do_reset(); return *this; } //@} //@{ /** * These versions of single-bit set, reset, flip, and test are * extensions from the SGI version. They do no range checking. * @ingroup SGIextensions */ bitset<_Nb>& _Unchecked_set(size_t __pos) _GLIBCXX_NOEXCEPT { this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) _GLIBCXX_NOEXCEPT { if (__val) this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); else this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_reset(size_t __pos) _GLIBCXX_NOEXCEPT { this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_flip(size_t __pos) _GLIBCXX_NOEXCEPT { this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); return *this; } _GLIBCXX_CONSTEXPR bool _Unchecked_test(size_t __pos) const _GLIBCXX_NOEXCEPT { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) != static_cast<_WordT>(0)); } //@} // Set, reset, and flip. /** * @brief Sets every bit to true. */ bitset<_Nb>& set() _GLIBCXX_NOEXCEPT { this->_M_do_set(); this->_M_do_sanitize(); return *this; } /** * @brief Sets a given bit to a particular value. * @param __position The index of the bit. * @param __val Either true or false, defaults to true. * @throw std::out_of_range If @a pos is bigger the size of the %set. */ bitset<_Nb>& set(size_t __position, bool __val = true) { this->_M_check(__position, __N("bitset::set")); return _Unchecked_set(__position, __val); } /** * @brief Sets every bit to false. */ bitset<_Nb>& reset() _GLIBCXX_NOEXCEPT { this->_M_do_reset(); return *this; } /** * @brief Sets a given bit to false. * @param __position The index of the bit. * @throw std::out_of_range If @a pos is bigger the size of the %set. * * Same as writing @c set(pos,false). */ bitset<_Nb>& reset(size_t __position) { this->_M_check(__position, __N("bitset::reset")); return _Unchecked_reset(__position); } /** * @brief Toggles every bit to its opposite value. */ bitset<_Nb>& flip() _GLIBCXX_NOEXCEPT { this->_M_do_flip(); this->_M_do_sanitize(); return *this; } /** * @brief Toggles a given bit to its opposite value. * @param __position The index of the bit. * @throw std::out_of_range If @a pos is bigger the size of the %set. */ bitset<_Nb>& flip(size_t __position) { this->_M_check(__position, __N("bitset::flip")); return _Unchecked_flip(__position); } /// See the no-argument flip(). bitset<_Nb> operator~() const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(*this).flip(); } //@{ /** * @brief Array-indexing support. * @param __position Index into the %bitset. * @return A bool for a const %bitset. For non-const * bitsets, an instance of the reference proxy class. * @note These operators do no range checking and throw no exceptions, * as required by DR 11 to the standard. * * _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already * resolves DR 11 (items 1 and 2), but does not do the range-checking * required by that DR's resolution. -pme * The DR has since been changed: range-checking is a precondition * (users' responsibility), and these functions must not throw. -pme */ reference operator[](size_t __position) { return reference(*this, __position); } _GLIBCXX_CONSTEXPR bool operator[](size_t __position) const { return _Unchecked_test(__position); } //@} /** * @brief Returns a numerical interpretation of the %bitset. * @return The integral equivalent of the bits. * @throw std::overflow_error If there are too many bits to be * represented in an @c unsigned @c long. */ unsigned long to_ulong() const { return this->_M_do_to_ulong(); } #if __cplusplus >= 201103L unsigned long long to_ullong() const { return this->_M_do_to_ullong(); } #endif /** * @brief Returns a character interpretation of the %bitset. * @return The string equivalent of the bits. * * Note the ordering of the bits: decreasing character positions * correspond to increasing bit positions (see the main class notes for * an example). */ template std::basic_string<_CharT, _Traits, _Alloc> to_string() const { std::basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result, _CharT('0'), _CharT('1')); return __result; } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 396. what are characters zero and one. template std::basic_string<_CharT, _Traits, _Alloc> to_string(_CharT __zero, _CharT __one = _CharT('1')) const { std::basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result, __zero, __one); return __result; } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 434. bitset::to_string() hard to use. template std::basic_string<_CharT, _Traits, std::allocator<_CharT> > to_string() const { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 853. to_string needs updating with zero and one. template std::basic_string<_CharT, _Traits, std::allocator<_CharT> > to_string(_CharT __zero, _CharT __one = _CharT('1')) const { return to_string<_CharT, _Traits, std::allocator<_CharT> >(__zero, __one); } template std::basic_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> > to_string() const { return to_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> >(); } template std::basic_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> > to_string(_CharT __zero, _CharT __one = _CharT('1')) const { return to_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> >(__zero, __one); } std::basic_string, std::allocator > to_string() const { return to_string, std::allocator >(); } std::basic_string, std::allocator > to_string(char __zero, char __one = '1') const { return to_string, std::allocator >(__zero, __one); } // Helper functions for string operations. template void _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t, _CharT, _CharT); template void _M_copy_from_string(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n, _CharT __zero, _CharT __one) { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n, __zero, __one); } template void _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&, _CharT, _CharT) const; // NB: Backward compat. template void _M_copy_from_string(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n) { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); } template void _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); } /// Returns the number of bits which are set. size_t count() const _GLIBCXX_NOEXCEPT { return this->_M_do_count(); } /// Returns the total number of bits. _GLIBCXX_CONSTEXPR size_t size() const _GLIBCXX_NOEXCEPT { return _Nb; } //@{ /// These comparisons for equality/inequality are, well, @e bitwise. bool operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return this->_M_is_equal(__rhs); } bool operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return !this->_M_is_equal(__rhs); } //@} /** * @brief Tests the value of a bit. * @param __position The index of a bit. * @return The value at @a pos. * @throw std::out_of_range If @a pos is bigger the size of the %set. */ bool test(size_t __position) const { this->_M_check(__position, __N("bitset::test")); return _Unchecked_test(__position); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 693. std::bitset::all() missing. /** * @brief Tests whether all the bits are on. * @return True if all the bits are set. */ bool all() const _GLIBCXX_NOEXCEPT { return this->template _M_are_all<_Nb>(); } /** * @brief Tests whether any of the bits are on. * @return True if at least one bit is set. */ bool any() const _GLIBCXX_NOEXCEPT { return this->_M_is_any(); } /** * @brief Tests whether any of the bits are on. * @return True if none of the bits are set. */ bool none() const _GLIBCXX_NOEXCEPT { return !this->_M_is_any(); } //@{ /// Self-explanatory. bitset<_Nb> operator<<(size_t __position) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(*this) <<= __position; } bitset<_Nb> operator>>(size_t __position) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(*this) >>= __position; } //@} /** * @brief Finds the index of the first "on" bit. * @return The index of the first bit set, or size() if not found. * @ingroup SGIextensions * @sa _Find_next */ size_t _Find_first() const _GLIBCXX_NOEXCEPT { return this->_M_do_find_first(_Nb); } /** * @brief Finds the index of the next "on" bit after prev. * @return The index of the next bit set, or size() if not found. * @param __prev Where to start searching. * @ingroup SGIextensions * @sa _Find_first */ size_t _Find_next(size_t __prev) const _GLIBCXX_NOEXCEPT { return this->_M_do_find_next(__prev, _Nb); } }; // Definitions of non-inline member functions. template template void bitset<_Nb>:: _M_copy_from_ptr(const _CharT* __s, size_t __len, size_t __pos, size_t __n, _CharT __zero, _CharT __one) { reset(); const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos))); for (size_t __i = __nbits; __i > 0; --__i) { const _CharT __c = __s[__pos + __nbits - __i]; if (_Traits::eq(__c, __zero)) ; else if (_Traits::eq(__c, __one)) _Unchecked_set(__i - 1); else __throw_invalid_argument(__N("bitset::_M_copy_from_ptr")); } } template template void bitset<_Nb>:: _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s, _CharT __zero, _CharT __one) const { __s.assign(_Nb, __zero); for (size_t __i = _Nb; __i > 0; --__i) if (_Unchecked_test(__i - 1)) _Traits::assign(__s[_Nb - __i], __one); } // 23.3.5.3 bitset operations: //@{ /** * @brief Global bitwise operations on bitsets. * @param __x A bitset. * @param __y A bitset of the same size as @a __x. * @return A new bitset. * * These should be self-explanatory. */ template inline bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { bitset<_Nb> __result(__x); __result &= __y; return __result; } template inline bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { bitset<_Nb> __result(__x); __result |= __y; return __result; } template inline bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT { bitset<_Nb> __result(__x); __result ^= __y; return __result; } //@} //@{ /** * @brief Global I/O operators for bitsets. * * Direct I/O between streams and bitsets is supported. Output is * straightforward. Input will skip whitespace, only accept @a 0 and @a 1 * characters, and will only extract as many digits as the %bitset will * hold. */ template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) { typedef typename _Traits::char_type char_type; typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; std::basic_string<_CharT, _Traits> __tmp; __tmp.reserve(_Nb); // _GLIBCXX_RESOLVE_LIB_DEFECTS // 303. Bitset input operator underspecified const char_type __zero = __is.widen('0'); const char_type __one = __is.widen('1'); typename __ios_base::iostate __state = __ios_base::goodbit; typename __istream_type::sentry __sentry(__is); if (__sentry) { __try { for (size_t __i = _Nb; __i > 0; --__i) { static typename _Traits::int_type __eof = _Traits::eof(); typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { __state |= __ios_base::eofbit; break; } else { const char_type __c2 = _Traits::to_char_type(__c1); if (_Traits::eq(__c2, __zero)) __tmp.push_back(__zero); else if (_Traits::eq(__c2, __one)) __tmp.push_back(__one); else if (_Traits:: eq_int_type(__is.rdbuf()->sputbackc(__c2), __eof)) { __state |= __ios_base::failbit; break; } } } } __catch(__cxxabiv1::__forced_unwind&) { __is._M_setstate(__ios_base::badbit); __throw_exception_again; } __catch(...) { __is._M_setstate(__ios_base::badbit); } } if (__tmp.empty() && _Nb) __state |= __ios_base::failbit; else __x._M_copy_from_string(__tmp, static_cast(0), _Nb, __zero, __one); if (__state) __is.setstate(__state); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x) { std::basic_string<_CharT, _Traits> __tmp; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 396. what are characters zero and one. const ctype<_CharT>& __ct = use_facet >(__os.getloc()); __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); return __os << __tmp; } //@} _GLIBCXX_END_NAMESPACE_CONTAINER } // namespace std #undef _GLIBCXX_BITSET_WORDS #undef _GLIBCXX_BITSET_BITS_PER_WORD #undef _GLIBCXX_BITSET_BITS_PER_ULL #if __cplusplus >= 201103L namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // DR 1182. /// std::hash specialization for bitset. template struct hash<_GLIBCXX_STD_C::bitset<_Nb>> : public __hash_base> { size_t operator()(const _GLIBCXX_STD_C::bitset<_Nb>& __b) const noexcept { const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__; return std::_Hash_impl::hash(__b._M_getdata(), __clength); } }; template<> struct hash<_GLIBCXX_STD_C::bitset<0>> : public __hash_base> { size_t operator()(const _GLIBCXX_STD_C::bitset<0>&) const noexcept { return 0; } }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // C++11 #ifdef _GLIBCXX_DEBUG # include #endif #ifdef _GLIBCXX_PROFILE # include #endif #endif /* _GLIBCXX_BITSET */ c++/8/codecvt000064400000012335152640040230006635 0ustar00// -*- C++ -*- // Copyright (C) 2015-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . // ISO C++ 14882: 22.5 Standard code conversion facets /** @file include/codecvt * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_CODECVT #define _GLIBCXX_CODECVT 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include #ifdef _GLIBCXX_USE_C99_STDINT_TR1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION enum codecvt_mode { consume_header = 4, generate_header = 2, little_endian = 1 }; template class codecvt_utf8 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf8(size_t __refs = 0); ~codecvt_utf8(); }; template class codecvt_utf16 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf16(size_t __refs = 0); ~codecvt_utf16(); }; template class codecvt_utf8_utf16 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf8_utf16(size_t __refs = 0); ~codecvt_utf8_utf16(); }; #define _GLIBCXX_CODECVT_SPECIALIZATION2(_NAME, _ELEM) \ template<> \ class _NAME<_ELEM> \ : public codecvt<_ELEM, char, mbstate_t> \ { \ public: \ typedef _ELEM intern_type; \ typedef char extern_type; \ typedef mbstate_t state_type; \ \ protected: \ _NAME(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) \ : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } \ \ virtual \ ~_NAME(); \ \ virtual result \ do_out(state_type& __state, const intern_type* __from, \ const intern_type* __from_end, const intern_type*& __from_next, \ extern_type* __to, extern_type* __to_end, \ extern_type*& __to_next) const; \ \ virtual result \ do_unshift(state_type& __state, \ extern_type* __to, extern_type* __to_end, \ extern_type*& __to_next) const; \ \ virtual result \ do_in(state_type& __state, \ const extern_type* __from, const extern_type* __from_end, \ const extern_type*& __from_next, \ intern_type* __to, intern_type* __to_end, \ intern_type*& __to_next) const; \ \ virtual \ int do_encoding() const throw(); \ \ virtual \ bool do_always_noconv() const throw(); \ \ virtual \ int do_length(state_type&, const extern_type* __from, \ const extern_type* __end, size_t __max) const; \ \ virtual int \ do_max_length() const throw(); \ \ private: \ unsigned long _M_maxcode; \ codecvt_mode _M_mode; \ } #define _GLIBCXX_CODECVT_SPECIALIZATION(_NAME, _ELEM) \ _GLIBCXX_CODECVT_SPECIALIZATION2(__ ## _NAME ## _base, _ELEM); \ template \ class _NAME<_ELEM, _Maxcode, _Mode> \ : public __ ## _NAME ## _base<_ELEM> \ { \ public: \ explicit \ _NAME(size_t __refs = 0) \ : __ ## _NAME ## _base<_ELEM>(std::min(_Maxcode, 0x10fffful), \ _Mode, __refs) \ { } \ } template class __codecvt_utf8_base; template class __codecvt_utf16_base; template class __codecvt_utf8_utf16_base; _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8, char16_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf16, char16_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8_utf16, char16_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8, char32_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf16, char32_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8_utf16, char32_t); #ifdef _GLIBCXX_USE_WCHAR_T _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8, wchar_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf16, wchar_t); _GLIBCXX_CODECVT_SPECIALIZATION(codecvt_utf8_utf16, wchar_t); #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // _GLIBCXX_USE_C99_STDINT_TR1 #endif #endif /* _GLIBCXX_CODECVT */ c++/8/mutex000064400000043460152640040230006353 0ustar00// -*- C++ -*- // Copyright (C) 2003-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/mutex * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_MUTEX #define _GLIBCXX_MUTEX 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include #include #include #include #include #if ! _GTHREAD_USE_MUTEX_TIMEDLOCK # include # include #endif #ifndef _GLIBCXX_HAVE_TLS # include #endif #ifdef _GLIBCXX_USE_C99_STDINT_TR1 namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @ingroup mutexes * @{ */ #ifdef _GLIBCXX_HAS_GTHREADS // Common base class for std::recursive_mutex and std::recursive_timed_mutex class __recursive_mutex_base { protected: typedef __gthread_recursive_mutex_t __native_type; __recursive_mutex_base(const __recursive_mutex_base&) = delete; __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete; #ifdef __GTHREAD_RECURSIVE_MUTEX_INIT __native_type _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT; __recursive_mutex_base() = default; #else __native_type _M_mutex; __recursive_mutex_base() { // XXX EAGAIN, ENOMEM, EPERM, EBUSY(may), EINVAL(may) __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); } ~__recursive_mutex_base() { __gthread_recursive_mutex_destroy(&_M_mutex); } #endif }; /// The standard recursive mutex type. class recursive_mutex : private __recursive_mutex_base { public: typedef __native_type* native_handle_type; recursive_mutex() = default; ~recursive_mutex() = default; recursive_mutex(const recursive_mutex&) = delete; recursive_mutex& operator=(const recursive_mutex&) = delete; void lock() { int __e = __gthread_recursive_mutex_lock(&_M_mutex); // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) if (__e) __throw_system_error(__e); } bool try_lock() noexcept { // XXX EINVAL, EAGAIN, EBUSY return !__gthread_recursive_mutex_trylock(&_M_mutex); } void unlock() { // XXX EINVAL, EAGAIN, EBUSY __gthread_recursive_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } }; #if _GTHREAD_USE_MUTEX_TIMEDLOCK template class __timed_mutex_impl { protected: typedef chrono::high_resolution_clock __clock_t; template bool _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { using chrono::steady_clock; auto __rt = chrono::duration_cast(__rtime); if (ratio_greater()) ++__rt; return _M_try_lock_until(steady_clock::now() + __rt); } template bool _M_try_lock_until(const chrono::time_point<__clock_t, _Duration>& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; return static_cast<_Derived*>(this)->_M_timedlock(__ts); } template bool _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { auto __rtime = __atime - _Clock::now(); return _M_try_lock_until(__clock_t::now() + __rtime); } }; /// The standard timed mutex type. class timed_mutex : private __mutex_base, public __timed_mutex_impl { public: typedef __native_type* native_handle_type; timed_mutex() = default; ~timed_mutex() = default; timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete; void lock() { int __e = __gthread_mutex_lock(&_M_mutex); // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) if (__e) __throw_system_error(__e); } bool try_lock() noexcept { // XXX EINVAL, EAGAIN, EBUSY return !__gthread_mutex_trylock(&_M_mutex); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { return _M_try_lock_for(__rtime); } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { return _M_try_lock_until(__atime); } void unlock() { // XXX EINVAL, EAGAIN, EBUSY __gthread_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } private: friend class __timed_mutex_impl; bool _M_timedlock(const __gthread_time_t& __ts) { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); } }; /// recursive_timed_mutex class recursive_timed_mutex : private __recursive_mutex_base, public __timed_mutex_impl { public: typedef __native_type* native_handle_type; recursive_timed_mutex() = default; ~recursive_timed_mutex() = default; recursive_timed_mutex(const recursive_timed_mutex&) = delete; recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock() { int __e = __gthread_recursive_mutex_lock(&_M_mutex); // EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may) if (__e) __throw_system_error(__e); } bool try_lock() noexcept { // XXX EINVAL, EAGAIN, EBUSY return !__gthread_recursive_mutex_trylock(&_M_mutex); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { return _M_try_lock_for(__rtime); } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { return _M_try_lock_until(__atime); } void unlock() { // XXX EINVAL, EAGAIN, EBUSY __gthread_recursive_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } private: friend class __timed_mutex_impl; bool _M_timedlock(const __gthread_time_t& __ts) { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); } }; #else // !_GTHREAD_USE_MUTEX_TIMEDLOCK /// timed_mutex class timed_mutex { mutex _M_mut; condition_variable _M_cv; bool _M_locked = false; public: timed_mutex() = default; ~timed_mutex() { __glibcxx_assert( !_M_locked ); } timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete; void lock() { unique_lock __lk(_M_mut); _M_cv.wait(__lk, [&]{ return !_M_locked; }); _M_locked = true; } bool try_lock() { lock_guard __lk(_M_mut); if (_M_locked) return false; _M_locked = true; return true; } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { unique_lock __lk(_M_mut); if (!_M_cv.wait_for(__lk, __rtime, [&]{ return !_M_locked; })) return false; _M_locked = true; return true; } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { unique_lock __lk(_M_mut); if (!_M_cv.wait_until(__lk, __atime, [&]{ return !_M_locked; })) return false; _M_locked = true; return true; } void unlock() { lock_guard __lk(_M_mut); __glibcxx_assert( _M_locked ); _M_locked = false; _M_cv.notify_one(); } }; /// recursive_timed_mutex class recursive_timed_mutex { mutex _M_mut; condition_variable _M_cv; thread::id _M_owner; unsigned _M_count = 0; // Predicate type that tests whether the current thread can lock a mutex. struct _Can_lock { // Returns true if the mutex is unlocked or is locked by _M_caller. bool operator()() const noexcept { return _M_mx->_M_count == 0 || _M_mx->_M_owner == _M_caller; } const recursive_timed_mutex* _M_mx; thread::id _M_caller; }; public: recursive_timed_mutex() = default; ~recursive_timed_mutex() { __glibcxx_assert( _M_count == 0 ); } recursive_timed_mutex(const recursive_timed_mutex&) = delete; recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock() { auto __id = this_thread::get_id(); _Can_lock __can_lock{this, __id}; unique_lock __lk(_M_mut); _M_cv.wait(__lk, __can_lock); if (_M_count == -1u) __throw_system_error(EAGAIN); // [thread.timedmutex.recursive]/3 _M_owner = __id; ++_M_count; } bool try_lock() { auto __id = this_thread::get_id(); _Can_lock __can_lock{this, __id}; lock_guard __lk(_M_mut); if (!__can_lock()) return false; if (_M_count == -1u) return false; _M_owner = __id; ++_M_count; return true; } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { auto __id = this_thread::get_id(); _Can_lock __can_lock{this, __id}; unique_lock __lk(_M_mut); if (!_M_cv.wait_for(__lk, __rtime, __can_lock)) return false; if (_M_count == -1u) return false; _M_owner = __id; ++_M_count; return true; } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { auto __id = this_thread::get_id(); _Can_lock __can_lock{this, __id}; unique_lock __lk(_M_mut); if (!_M_cv.wait_until(__lk, __atime, __can_lock)) return false; if (_M_count == -1u) return false; _M_owner = __id; ++_M_count; return true; } void unlock() { lock_guard __lk(_M_mut); __glibcxx_assert( _M_owner == this_thread::get_id() ); __glibcxx_assert( _M_count > 0 ); if (--_M_count == 0) { _M_owner = {}; _M_cv.notify_one(); } } }; #endif #endif // _GLIBCXX_HAS_GTHREADS template inline unique_lock<_Lock> __try_to_lock(_Lock& __l) { return unique_lock<_Lock>{__l, try_to_lock}; } template struct __try_lock_impl { template static void __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) { __idx = _Idx; auto __lock = std::__try_to_lock(std::get<_Idx>(__locks)); if (__lock.owns_lock()) { constexpr bool __cont = _Idx + 2 < sizeof...(_Lock); using __try_locker = __try_lock_impl<_Idx + 1, __cont>; __try_locker::__do_try_lock(__locks, __idx); if (__idx == -1) __lock.release(); } } }; template struct __try_lock_impl<_Idx, false> { template static void __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) { __idx = _Idx; auto __lock = std::__try_to_lock(std::get<_Idx>(__locks)); if (__lock.owns_lock()) { __idx = -1; __lock.release(); } } }; /** @brief Generic try_lock. * @param __l1 Meets Lockable requirements (try_lock() may throw). * @param __l2 Meets Lockable requirements (try_lock() may throw). * @param __l3 Meets Lockable requirements (try_lock() may throw). * @return Returns -1 if all try_lock() calls return true. Otherwise returns * a 0-based index corresponding to the argument that returned false. * @post Either all arguments are locked, or none will be. * * Sequentially calls try_lock() on each argument. */ template int try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3) { int __idx; auto __locks = std::tie(__l1, __l2, __l3...); __try_lock_impl<0>::__do_try_lock(__locks, __idx); return __idx; } /** @brief Generic lock. * @param __l1 Meets Lockable requirements (try_lock() may throw). * @param __l2 Meets Lockable requirements (try_lock() may throw). * @param __l3 Meets Lockable requirements (try_lock() may throw). * @throw An exception thrown by an argument's lock() or try_lock() member. * @post All arguments are locked. * * All arguments are locked via a sequence of calls to lock(), try_lock() * and unlock(). If the call exits via an exception any locks that were * obtained will be released. */ template void lock(_L1& __l1, _L2& __l2, _L3&... __l3) { while (true) { using __try_locker = __try_lock_impl<0, sizeof...(_L3) != 0>; unique_lock<_L1> __first(__l1); int __idx; auto __locks = std::tie(__l2, __l3...); __try_locker::__do_try_lock(__locks, __idx); if (__idx == -1) { __first.release(); return; } } } #if __cplusplus >= 201703L #define __cpp_lib_scoped_lock 201703 /** @brief A scoped lock type for multiple lockable objects. * * A scoped_lock controls mutex ownership within a scope, releasing * ownership in the destructor. */ template class scoped_lock { public: explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...)) { std::lock(__m...); } explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept : _M_devices(std::tie(__m...)) { } // calling thread owns mutex ~scoped_lock() { std::apply([](_MutexTypes&... __m) { char __i[] __attribute__((__unused__)) = { (__m.unlock(), 0)... }; }, _M_devices); } scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; private: tuple<_MutexTypes&...> _M_devices; }; template<> class scoped_lock<> { public: explicit scoped_lock() = default; explicit scoped_lock(adopt_lock_t) noexcept { } ~scoped_lock() = default; scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; }; template class scoped_lock<_Mutex> { public: using mutex_type = _Mutex; explicit scoped_lock(mutex_type& __m) : _M_device(__m) { _M_device.lock(); } explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept : _M_device(__m) { } // calling thread owns mutex ~scoped_lock() { _M_device.unlock(); } scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; private: mutex_type& _M_device; }; #endif // C++17 #ifdef _GLIBCXX_HAS_GTHREADS /// once_flag struct once_flag { private: typedef __gthread_once_t __native_type; __native_type _M_once = __GTHREAD_ONCE_INIT; public: /// Constructor constexpr once_flag() noexcept = default; /// Deleted copy constructor once_flag(const once_flag&) = delete; /// Deleted assignment operator once_flag& operator=(const once_flag&) = delete; template friend void call_once(once_flag& __once, _Callable&& __f, _Args&&... __args); }; #ifdef _GLIBCXX_HAVE_TLS extern __thread void* __once_callable; extern __thread void (*__once_call)(); #else extern function __once_functor; extern void __set_once_functor_lock_ptr(unique_lock*); extern mutex& __get_once_mutex(); #endif extern "C" void __once_proxy(void); /// call_once template void call_once(once_flag& __once, _Callable&& __f, _Args&&... __args) { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2442. call_once() shouldn't DECAY_COPY() auto __callable = [&] { std::__invoke(std::forward<_Callable>(__f), std::forward<_Args>(__args)...); }; #ifdef _GLIBCXX_HAVE_TLS __once_callable = std::__addressof(__callable); // NOLINT: PR 82481 __once_call = []{ (*(decltype(__callable)*)__once_callable)(); }; #else unique_lock __functor_lock(__get_once_mutex()); __once_functor = __callable; __set_once_functor_lock_ptr(&__functor_lock); #endif int __e = __gthread_once(&__once._M_once, &__once_proxy); #ifndef _GLIBCXX_HAVE_TLS if (__functor_lock) __set_once_functor_lock_ptr(0); #endif if (__e) __throw_system_error(__e); } #endif // _GLIBCXX_HAS_GTHREADS // @} group mutexes _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif // _GLIBCXX_USE_C99_STDINT_TR1 #endif // C++11 #endif // _GLIBCXX_MUTEX c++/8/ccomplex000064400000002467152640040230007025 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/ccomplex * This is a Standard C++ Library header. */ #pragma GCC system_header #ifndef _GLIBCXX_CCOMPLEX #define _GLIBCXX_CCOMPLEX 1 #if __cplusplus < 201103L # include #endif extern "C++" { #include } #endif c++/8/tgmath.h000064400000002520152640040230006713 0ustar00// -*- C++ -*- compatibility header. // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file tgmath.h * This is a Standard C++ Library header. */ #include #if __cplusplus >= 201103L # include #else # if _GLIBCXX_HAVE_TGMATH_H # include_next # endif #endif #ifndef _GLIBCXX_TGMATH_H #define _GLIBCXX_TGMATH_H 1 #endif c++/8/cstring000064400000006063152640040230006660 0ustar00// -*- C++ -*- forwarding header. // Copyright (C) 1997-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file cstring * This is a Standard C++ Library file. You should @c \#include this file * in your programs, rather than any of the @a *.h implementation files. * * This is the C++ version of the Standard C Library header @c string.h, * and its contents are (mostly) the same as that header, but are all * contained in the namespace @c std (except for names which are defined * as macros in C). */ // // ISO C++ 14882: 20.4.6 C library // #pragma GCC system_header #include #include #ifndef _GLIBCXX_CSTRING #define _GLIBCXX_CSTRING 1 // Get rid of those macros defined in in lieu of real functions. #undef memchr #undef memcmp #undef memcpy #undef memmove #undef memset #undef strcat #undef strchr #undef strcmp #undef strcoll #undef strcpy #undef strcspn #undef strerror #undef strlen #undef strncat #undef strncmp #undef strncpy #undef strpbrk #undef strrchr #undef strspn #undef strstr #undef strtok #undef strxfrm namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION using ::memchr; using ::memcmp; using ::memcpy; using ::memmove; using ::memset; using ::strcat; using ::strcmp; using ::strcoll; using ::strcpy; using ::strcspn; using ::strerror; using ::strlen; using ::strncat; using ::strncmp; using ::strncpy; using ::strspn; using ::strtok; using ::strxfrm; using ::strchr; using ::strpbrk; using ::strrchr; using ::strstr; #ifndef __CORRECT_ISO_CPP_STRING_H_PROTO inline void* memchr(void* __s, int __c, size_t __n) { return __builtin_memchr(__s, __c, __n); } inline char* strchr(char* __s, int __n) { return __builtin_strchr(__s, __n); } inline char* strpbrk(char* __s1, const char* __s2) { return __builtin_strpbrk(__s1, __s2); } inline char* strrchr(char* __s, int __n) { return __builtin_strrchr(__s, __n); } inline char* strstr(char* __s1, const char* __s2) { return __builtin_strstr(__s1, __s2); } #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif c++/8/type_traits000064400000247557152640040230007575 0ustar00// C++11 -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file include/type_traits * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_TYPE_TRAITS #define _GLIBCXX_TYPE_TRAITS 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @defgroup metaprogramming Metaprogramming * @ingroup utilities * * Template utilities for compile-time introspection and modification, * including type classification traits, type property inspection traits * and type transformation traits. * * @{ */ /// integral_constant template struct integral_constant { static constexpr _Tp value = __v; typedef _Tp value_type; typedef integral_constant<_Tp, __v> type; constexpr operator value_type() const noexcept { return value; } #if __cplusplus > 201103L #define __cpp_lib_integral_constant_callable 201304 constexpr value_type operator()() const noexcept { return value; } #endif }; template constexpr _Tp integral_constant<_Tp, __v>::value; /// The type used as a compile-time boolean with true value. typedef integral_constant true_type; /// The type used as a compile-time boolean with false value. typedef integral_constant false_type; template using __bool_constant = integral_constant; #if __cplusplus > 201402L # define __cpp_lib_bool_constant 201505 template using bool_constant = integral_constant; #endif // Meta programming helper types. template struct conditional; template struct __or_; template<> struct __or_<> : public false_type { }; template struct __or_<_B1> : public _B1 { }; template struct __or_<_B1, _B2> : public conditional<_B1::value, _B1, _B2>::type { }; template struct __or_<_B1, _B2, _B3, _Bn...> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type { }; template struct __and_; template<> struct __and_<> : public true_type { }; template struct __and_<_B1> : public _B1 { }; template struct __and_<_B1, _B2> : public conditional<_B1::value, _B2, _B1>::type { }; template struct __and_<_B1, _B2, _B3, _Bn...> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type { }; template struct __not_ : public __bool_constant { }; #if __cplusplus >= 201703L #define __cpp_lib_logical_traits 201510 template struct conjunction : __and_<_Bn...> { }; template struct disjunction : __or_<_Bn...> { }; template struct negation : __not_<_Pp> { }; template inline constexpr bool conjunction_v = conjunction<_Bn...>::value; template inline constexpr bool disjunction_v = disjunction<_Bn...>::value; template inline constexpr bool negation_v = negation<_Pp>::value; #endif // C++17 // For several sfinae-friendly trait implementations we transport both the // result information (as the member type) and the failure information (no // member type). This is very similar to std::enable_if, but we cannot use // them, because we need to derive from them as an implementation detail. template struct __success_type { typedef _Tp type; }; struct __failure_type { }; // Primary type categories. template struct remove_cv; template struct __is_void_helper : public false_type { }; template<> struct __is_void_helper : public true_type { }; /// is_void template struct is_void : public __is_void_helper::type>::type { }; template struct __is_integral_helper : public false_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; #ifdef _GLIBCXX_USE_WCHAR_T template<> struct __is_integral_helper : public true_type { }; #endif template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; // Conditionalizing on __STRICT_ANSI__ here will break any port that // uses one of these types for size_t. #if defined(__GLIBCXX_TYPE_INT_N_0) template<> struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0> : public true_type { }; template<> struct __is_integral_helper : public true_type { }; #endif #if defined(__GLIBCXX_TYPE_INT_N_1) template<> struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1> : public true_type { }; template<> struct __is_integral_helper : public true_type { }; #endif #if defined(__GLIBCXX_TYPE_INT_N_2) template<> struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2> : public true_type { }; template<> struct __is_integral_helper : public true_type { }; #endif #if defined(__GLIBCXX_TYPE_INT_N_3) template<> struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3> : public true_type { }; template<> struct __is_integral_helper : public true_type { }; #endif /// is_integral template struct is_integral : public __is_integral_helper::type>::type { }; template struct __is_floating_point_helper : public false_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) template<> struct __is_floating_point_helper<__float128> : public true_type { }; #endif /// is_floating_point template struct is_floating_point : public __is_floating_point_helper::type>::type { }; /// is_array template struct is_array : public false_type { }; template struct is_array<_Tp[_Size]> : public true_type { }; template struct is_array<_Tp[]> : public true_type { }; template struct __is_pointer_helper : public false_type { }; template struct __is_pointer_helper<_Tp*> : public true_type { }; /// is_pointer template struct is_pointer : public __is_pointer_helper::type>::type { }; /// is_lvalue_reference template struct is_lvalue_reference : public false_type { }; template struct is_lvalue_reference<_Tp&> : public true_type { }; /// is_rvalue_reference template struct is_rvalue_reference : public false_type { }; template struct is_rvalue_reference<_Tp&&> : public true_type { }; template struct is_function; template struct __is_member_object_pointer_helper : public false_type { }; template struct __is_member_object_pointer_helper<_Tp _Cp::*> : public integral_constant::value> { }; /// is_member_object_pointer template struct is_member_object_pointer : public __is_member_object_pointer_helper< typename remove_cv<_Tp>::type>::type { }; template struct __is_member_function_pointer_helper : public false_type { }; template struct __is_member_function_pointer_helper<_Tp _Cp::*> : public integral_constant::value> { }; /// is_member_function_pointer template struct is_member_function_pointer : public __is_member_function_pointer_helper< typename remove_cv<_Tp>::type>::type { }; /// is_enum template struct is_enum : public integral_constant { }; /// is_union template struct is_union : public integral_constant { }; /// is_class template struct is_class : public integral_constant { }; /// is_function template struct is_function : public false_type { }; template struct is_function<_Res(_ArgTypes...) _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) volatile _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) volatile & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) volatile && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) volatile _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) volatile & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) volatile && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const volatile _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const volatile & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes...) const volatile && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const volatile _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const volatile & _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct is_function<_Res(_ArgTypes......) const volatile && _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; #define __cpp_lib_is_null_pointer 201309 template struct __is_null_pointer_helper : public false_type { }; template<> struct __is_null_pointer_helper : public true_type { }; /// is_null_pointer (LWG 2247). template struct is_null_pointer : public __is_null_pointer_helper::type>::type { }; /// __is_nullptr_t (extension). template struct __is_nullptr_t : public is_null_pointer<_Tp> { }; // Composite type categories. /// is_reference template struct is_reference : public __or_, is_rvalue_reference<_Tp>>::type { }; /// is_arithmetic template struct is_arithmetic : public __or_, is_floating_point<_Tp>>::type { }; /// is_fundamental template struct is_fundamental : public __or_, is_void<_Tp>, is_null_pointer<_Tp>>::type { }; /// is_object template struct is_object : public __not_<__or_, is_reference<_Tp>, is_void<_Tp>>>::type { }; template struct is_member_pointer; /// is_scalar template struct is_scalar : public __or_, is_enum<_Tp>, is_pointer<_Tp>, is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type { }; /// is_compound template struct is_compound : public integral_constant::value> { }; template struct __is_member_pointer_helper : public false_type { }; template struct __is_member_pointer_helper<_Tp _Cp::*> : public true_type { }; /// is_member_pointer template struct is_member_pointer : public __is_member_pointer_helper::type>::type { }; // Utility to detect referenceable types ([defns.referenceable]). template struct __is_referenceable : public __or_, is_reference<_Tp>>::type { }; template struct __is_referenceable<_Res(_Args...) _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; template struct __is_referenceable<_Res(_Args......) _GLIBCXX_NOEXCEPT_QUAL> : public true_type { }; // Type properties. /// is_const template struct is_const : public false_type { }; template struct is_const<_Tp const> : public true_type { }; /// is_volatile template struct is_volatile : public false_type { }; template struct is_volatile<_Tp volatile> : public true_type { }; /// is_trivial template struct is_trivial : public integral_constant { }; // is_trivially_copyable template struct is_trivially_copyable : public integral_constant { }; /// is_standard_layout template struct is_standard_layout : public integral_constant { }; /// is_pod // Could use is_standard_layout && is_trivial instead of the builtin. template struct is_pod : public integral_constant { }; /// is_literal_type template struct is_literal_type : public integral_constant { }; /// is_empty template struct is_empty : public integral_constant { }; /// is_polymorphic template struct is_polymorphic : public integral_constant { }; #if __cplusplus >= 201402L #define __cpp_lib_is_final 201402L /// is_final template struct is_final : public integral_constant { }; #endif /// is_abstract template struct is_abstract : public integral_constant { }; template::value> struct __is_signed_helper : public false_type { }; template struct __is_signed_helper<_Tp, true> : public integral_constant { }; /// is_signed template struct is_signed : public __is_signed_helper<_Tp>::type { }; /// is_unsigned template struct is_unsigned : public __and_, __not_>> { }; // Destructible and constructible type properties. /** * @brief Utility to simplify expressions used in unevaluated operands * @ingroup utilities */ template _Up __declval(int); template _Tp __declval(long); template auto declval() noexcept -> decltype(__declval<_Tp>(0)); template struct extent; template struct remove_all_extents; template struct __is_array_known_bounds : public integral_constant::value > 0)> { }; template struct __is_array_unknown_bounds : public __and_, __not_>> { }; // In N3290 is_destructible does not say anything about function // types and abstract types, see LWG 2049. This implementation // describes function types as non-destructible and all complete // object types as destructible, iff the explicit destructor // call expression is wellformed. struct __do_is_destructible_impl { template().~_Tp())> static true_type __test(int); template static false_type __test(...); }; template struct __is_destructible_impl : public __do_is_destructible_impl { typedef decltype(__test<_Tp>(0)) type; }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_destructible_safe; template struct __is_destructible_safe<_Tp, false, false> : public __is_destructible_impl::type>::type { }; template struct __is_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_destructible_safe<_Tp, false, true> : public true_type { }; /// is_destructible template struct is_destructible : public __is_destructible_safe<_Tp>::type { }; // is_nothrow_destructible requires that is_destructible is // satisfied as well. We realize that by mimicing the // implementation of is_destructible but refer to noexcept(expr) // instead of decltype(expr). struct __do_is_nt_destructible_impl { template static integral_constant().~_Tp())> __test(int); template static false_type __test(...); }; template struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { typedef decltype(__test<_Tp>(0)) type; }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_nt_destructible_safe; template struct __is_nt_destructible_safe<_Tp, false, false> : public __is_nt_destructible_impl::type>::type { }; template struct __is_nt_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_nt_destructible_safe<_Tp, false, true> : public true_type { }; /// is_nothrow_destructible template struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type { }; /// is_constructible template struct is_constructible : public __bool_constant<__is_constructible(_Tp, _Args...)> { }; /// is_default_constructible template struct is_default_constructible : public is_constructible<_Tp>::type { }; template::value> struct __is_copy_constructible_impl; template struct __is_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_copy_constructible_impl<_Tp, true> : public is_constructible<_Tp, const _Tp&> { }; /// is_copy_constructible template struct is_copy_constructible : public __is_copy_constructible_impl<_Tp> { }; template::value> struct __is_move_constructible_impl; template struct __is_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_move_constructible_impl<_Tp, true> : public is_constructible<_Tp, _Tp&&> { }; /// is_move_constructible template struct is_move_constructible : public __is_move_constructible_impl<_Tp> { }; template struct __is_nt_constructible_impl : public false_type { }; template struct __is_nt_constructible_impl : public __bool_constant()...))> { }; template struct __is_nt_constructible_impl : public __bool_constant(std::declval<_Arg>()))> { }; template struct __is_nt_constructible_impl : public __bool_constant { }; template struct __is_nt_constructible_impl : public __bool_constant::type())> { }; template using __is_nothrow_constructible_impl = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...), _Tp, _Args...>; /// is_nothrow_constructible template struct is_nothrow_constructible : public __is_nothrow_constructible_impl<_Tp, _Args...>::type { }; /// is_nothrow_default_constructible template struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl<_Tp>::type { }; template::value> struct __is_nothrow_copy_constructible_impl; template struct __is_nothrow_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_nothrow_copy_constructible_impl<_Tp, true> : public is_nothrow_constructible<_Tp, const _Tp&> { }; /// is_nothrow_copy_constructible template struct is_nothrow_copy_constructible : public __is_nothrow_copy_constructible_impl<_Tp> { }; template::value> struct __is_nothrow_move_constructible_impl; template struct __is_nothrow_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_nothrow_move_constructible_impl<_Tp, true> : public is_nothrow_constructible<_Tp, _Tp&&> { }; /// is_nothrow_move_constructible template struct is_nothrow_move_constructible : public __is_nothrow_move_constructible_impl<_Tp> { }; /// is_assignable template struct is_assignable : public __bool_constant<__is_assignable(_Tp, _Up)> { }; template::value> struct __is_copy_assignable_impl; template struct __is_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_copy_assignable_impl<_Tp, true> : public is_assignable<_Tp&, const _Tp&> { }; /// is_copy_assignable template struct is_copy_assignable : public __is_copy_assignable_impl<_Tp> { }; template::value> struct __is_move_assignable_impl; template struct __is_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_move_assignable_impl<_Tp, true> : public is_assignable<_Tp&, _Tp&&> { }; /// is_move_assignable template struct is_move_assignable : public __is_move_assignable_impl<_Tp> { }; template struct __is_nt_assignable_impl : public integral_constant() = declval<_Up>())> { }; /// is_nothrow_assignable template struct is_nothrow_assignable : public __and_, __is_nt_assignable_impl<_Tp, _Up>> { }; template::value> struct __is_nt_copy_assignable_impl; template struct __is_nt_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_nt_copy_assignable_impl<_Tp, true> : public is_nothrow_assignable<_Tp&, const _Tp&> { }; /// is_nothrow_copy_assignable template struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl<_Tp> { }; template::value> struct __is_nt_move_assignable_impl; template struct __is_nt_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_nt_move_assignable_impl<_Tp, true> : public is_nothrow_assignable<_Tp&, _Tp&&> { }; /// is_nothrow_move_assignable template struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> { }; /// is_trivially_constructible template struct is_trivially_constructible : public __and_, __bool_constant< __is_trivially_constructible(_Tp, _Args...)>>::type { }; /// is_trivially_default_constructible template struct is_trivially_default_constructible : public is_trivially_constructible<_Tp>::type { }; struct __do_is_implicitly_default_constructible_impl { template static void __helper(const _Tp&); template static true_type __test(const _Tp&, decltype(__helper({}))* = 0); static false_type __test(...); }; template struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { typedef decltype(__test(declval<_Tp>())) type; }; template struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl<_Tp>::type { }; template struct __is_implicitly_default_constructible : public __and_, __is_implicitly_default_constructible_safe<_Tp>> { }; /// is_trivially_copy_constructible template::value> struct __is_trivially_copy_constructible_impl; template struct __is_trivially_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_trivially_copy_constructible_impl<_Tp, true> : public __and_, integral_constant> { }; template struct is_trivially_copy_constructible : public __is_trivially_copy_constructible_impl<_Tp> { }; /// is_trivially_move_constructible template::value> struct __is_trivially_move_constructible_impl; template struct __is_trivially_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_trivially_move_constructible_impl<_Tp, true> : public __and_, integral_constant> { }; template struct is_trivially_move_constructible : public __is_trivially_move_constructible_impl<_Tp> { }; /// is_trivially_assignable template struct is_trivially_assignable : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> { }; /// is_trivially_copy_assignable template::value> struct __is_trivially_copy_assignable_impl; template struct __is_trivially_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_trivially_copy_assignable_impl<_Tp, true> : public __and_, integral_constant> { }; template struct is_trivially_copy_assignable : public __is_trivially_copy_assignable_impl<_Tp> { }; /// is_trivially_move_assignable template::value> struct __is_trivially_move_assignable_impl; template struct __is_trivially_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_trivially_move_assignable_impl<_Tp, true> : public __and_, integral_constant> { }; template struct is_trivially_move_assignable : public __is_trivially_move_assignable_impl<_Tp> { }; /// is_trivially_destructible template struct is_trivially_destructible : public __and_, integral_constant> { }; /// has_virtual_destructor template struct has_virtual_destructor : public integral_constant { }; // type property queries. /// alignment_of template struct alignment_of : public integral_constant { }; /// rank template struct rank : public integral_constant { }; template struct rank<_Tp[_Size]> : public integral_constant::value> { }; template struct rank<_Tp[]> : public integral_constant::value> { }; /// extent template struct extent : public integral_constant { }; template struct extent<_Tp[_Size], _Uint> : public integral_constant::value> { }; template struct extent<_Tp[], _Uint> : public integral_constant::value> { }; // Type relations. /// is_same template struct is_same : public false_type { }; template struct is_same<_Tp, _Tp> : public true_type { }; /// is_base_of template struct is_base_of : public integral_constant { }; template, is_function<_To>, is_array<_To>>::value> struct __is_convertible_helper { typedef typename is_void<_To>::type type; }; template class __is_convertible_helper<_From, _To, false> { template static void __test_aux(_To1); template(std::declval<_From1>()))> static true_type __test(int); template static false_type __test(...); public: typedef decltype(__test<_From, _To>(0)) type; }; /// is_convertible template struct is_convertible : public __is_convertible_helper<_From, _To>::type { }; // Const-volatile modifications. /// remove_const template struct remove_const { typedef _Tp type; }; template struct remove_const<_Tp const> { typedef _Tp type; }; /// remove_volatile template struct remove_volatile { typedef _Tp type; }; template struct remove_volatile<_Tp volatile> { typedef _Tp type; }; /// remove_cv template struct remove_cv { typedef typename remove_const::type>::type type; }; /// add_const template struct add_const { typedef _Tp const type; }; /// add_volatile template struct add_volatile { typedef _Tp volatile type; }; /// add_cv template struct add_cv { typedef typename add_const::type>::type type; }; #if __cplusplus > 201103L #define __cpp_lib_transformation_trait_aliases 201304 /// Alias template for remove_const template using remove_const_t = typename remove_const<_Tp>::type; /// Alias template for remove_volatile template using remove_volatile_t = typename remove_volatile<_Tp>::type; /// Alias template for remove_cv template using remove_cv_t = typename remove_cv<_Tp>::type; /// Alias template for add_const template using add_const_t = typename add_const<_Tp>::type; /// Alias template for add_volatile template using add_volatile_t = typename add_volatile<_Tp>::type; /// Alias template for add_cv template using add_cv_t = typename add_cv<_Tp>::type; #endif // Reference transformations. /// remove_reference template struct remove_reference { typedef _Tp type; }; template struct remove_reference<_Tp&> { typedef _Tp type; }; template struct remove_reference<_Tp&&> { typedef _Tp type; }; template::value> struct __add_lvalue_reference_helper { typedef _Tp type; }; template struct __add_lvalue_reference_helper<_Tp, true> { typedef _Tp& type; }; /// add_lvalue_reference template struct add_lvalue_reference : public __add_lvalue_reference_helper<_Tp> { }; template::value> struct __add_rvalue_reference_helper { typedef _Tp type; }; template struct __add_rvalue_reference_helper<_Tp, true> { typedef _Tp&& type; }; /// add_rvalue_reference template struct add_rvalue_reference : public __add_rvalue_reference_helper<_Tp> { }; #if __cplusplus > 201103L /// Alias template for remove_reference template using remove_reference_t = typename remove_reference<_Tp>::type; /// Alias template for add_lvalue_reference template using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; /// Alias template for add_rvalue_reference template using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; #endif // Sign modifications. // Utility for constructing identically cv-qualified types. template struct __cv_selector; template struct __cv_selector<_Unqualified, false, false> { typedef _Unqualified __type; }; template struct __cv_selector<_Unqualified, false, true> { typedef volatile _Unqualified __type; }; template struct __cv_selector<_Unqualified, true, false> { typedef const _Unqualified __type; }; template struct __cv_selector<_Unqualified, true, true> { typedef const volatile _Unqualified __type; }; template::value, bool _IsVol = is_volatile<_Qualified>::value> class __match_cv_qualifiers { typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; public: typedef typename __match::__type __type; }; // Utility for finding the unsigned versions of signed integral types. template struct __make_unsigned { typedef _Tp __type; }; template<> struct __make_unsigned { typedef unsigned char __type; }; template<> struct __make_unsigned { typedef unsigned char __type; }; template<> struct __make_unsigned { typedef unsigned short __type; }; template<> struct __make_unsigned { typedef unsigned int __type; }; template<> struct __make_unsigned { typedef unsigned long __type; }; template<> struct __make_unsigned { typedef unsigned long long __type; }; #if defined(__GLIBCXX_TYPE_INT_N_0) template<> struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0> { typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_1) template<> struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1> { typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_2) template<> struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2> { typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_3) template<> struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3> { typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; }; #endif // Select between integral and enum: not possible to be both. template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_unsigned_selector; template class __make_unsigned_selector<_Tp, true, false> { typedef __make_unsigned::type> __unsignedt; typedef typename __unsignedt::__type __unsigned_type; typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; public: typedef typename __cv_unsigned::__type __type; }; template class __make_unsigned_selector<_Tp, false, true> { // With -fshort-enums, an enum may be as small as a char. typedef unsigned char __smallest; static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest); static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short); static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int); static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long); typedef conditional<__b3, unsigned long, unsigned long long> __cond3; typedef typename __cond3::type __cond3_type; typedef conditional<__b2, unsigned int, __cond3_type> __cond2; typedef typename __cond2::type __cond2_type; typedef conditional<__b1, unsigned short, __cond2_type> __cond1; typedef typename __cond1::type __cond1_type; typedef typename conditional<__b0, __smallest, __cond1_type>::type __unsigned_type; typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned; public: typedef typename __cv_unsigned::__type __type; }; // Given an integral/enum type, return the corresponding unsigned // integer type. // Primary template. /// make_unsigned template struct make_unsigned { typedef typename __make_unsigned_selector<_Tp>::__type type; }; // Integral, but don't define. template<> struct make_unsigned; // Utility for finding the signed versions of unsigned integral types. template struct __make_signed { typedef _Tp __type; }; template<> struct __make_signed { typedef signed char __type; }; template<> struct __make_signed { typedef signed char __type; }; template<> struct __make_signed { typedef signed short __type; }; template<> struct __make_signed { typedef signed int __type; }; template<> struct __make_signed { typedef signed long __type; }; template<> struct __make_signed { typedef signed long long __type; }; #if defined(__GLIBCXX_TYPE_INT_N_0) template<> struct __make_signed { typedef __GLIBCXX_TYPE_INT_N_0 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_1) template<> struct __make_signed { typedef __GLIBCXX_TYPE_INT_N_1 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_2) template<> struct __make_signed { typedef __GLIBCXX_TYPE_INT_N_2 __type; }; #endif #if defined(__GLIBCXX_TYPE_INT_N_3) template<> struct __make_signed { typedef __GLIBCXX_TYPE_INT_N_3 __type; }; #endif // Select between integral and enum: not possible to be both. template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_signed_selector; template class __make_signed_selector<_Tp, true, false> { typedef __make_signed::type> __signedt; typedef typename __signedt::__type __signed_type; typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed; public: typedef typename __cv_signed::__type __type; }; template class __make_signed_selector<_Tp, false, true> { typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; public: typedef typename __make_signed_selector<__unsigned_type>::__type __type; }; // Given an integral/enum type, return the corresponding signed // integer type. // Primary template. /// make_signed template struct make_signed { typedef typename __make_signed_selector<_Tp>::__type type; }; // Integral, but don't define. template<> struct make_signed; #if __cplusplus > 201103L /// Alias template for make_signed template using make_signed_t = typename make_signed<_Tp>::type; /// Alias template for make_unsigned template using make_unsigned_t = typename make_unsigned<_Tp>::type; #endif // Array modifications. /// remove_extent template struct remove_extent { typedef _Tp type; }; template struct remove_extent<_Tp[_Size]> { typedef _Tp type; }; template struct remove_extent<_Tp[]> { typedef _Tp type; }; /// remove_all_extents template struct remove_all_extents { typedef _Tp type; }; template struct remove_all_extents<_Tp[_Size]> { typedef typename remove_all_extents<_Tp>::type type; }; template struct remove_all_extents<_Tp[]> { typedef typename remove_all_extents<_Tp>::type type; }; #if __cplusplus > 201103L /// Alias template for remove_extent template using remove_extent_t = typename remove_extent<_Tp>::type; /// Alias template for remove_all_extents template using remove_all_extents_t = typename remove_all_extents<_Tp>::type; #endif // Pointer modifications. template struct __remove_pointer_helper { typedef _Tp type; }; template struct __remove_pointer_helper<_Tp, _Up*> { typedef _Up type; }; /// remove_pointer template struct remove_pointer : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> { }; /// add_pointer template, is_void<_Tp>>::value> struct __add_pointer_helper { typedef _Tp type; }; template struct __add_pointer_helper<_Tp, true> { typedef typename remove_reference<_Tp>::type* type; }; template struct add_pointer : public __add_pointer_helper<_Tp> { }; #if __cplusplus > 201103L /// Alias template for remove_pointer template using remove_pointer_t = typename remove_pointer<_Tp>::type; /// Alias template for add_pointer template using add_pointer_t = typename add_pointer<_Tp>::type; #endif template struct __aligned_storage_msa { union __type { unsigned char __data[_Len]; struct __attribute__((__aligned__)) { } __align; }; }; /** * @brief Alignment type. * * The value of _Align is a default-alignment which shall be the * most stringent alignment requirement for any C++ object type * whose size is no greater than _Len (3.9). The member typedef * type shall be a POD type suitable for use as uninitialized * storage for any object whose size is at most _Len and whose * alignment is a divisor of _Align. */ template::__type)> struct aligned_storage { union type { unsigned char __data[_Len]; struct __attribute__((__aligned__((_Align)))) { } __align; }; }; template struct __strictest_alignment { static const size_t _S_alignment = 0; static const size_t _S_size = 0; }; template struct __strictest_alignment<_Tp, _Types...> { static const size_t _S_alignment = alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; static const size_t _S_size = sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; }; /** * @brief Provide aligned storage for types. * * [meta.trans.other] * * Provides aligned storage for any of the provided types of at * least size _Len. * * @see aligned_storage */ template struct aligned_union { private: static_assert(sizeof...(_Types) != 0, "At least one type is required"); using __strictest = __strictest_alignment<_Types...>; static const size_t _S_len = _Len > __strictest::_S_size ? _Len : __strictest::_S_size; public: /// The value of the strictest alignment of _Types. static const size_t alignment_value = __strictest::_S_alignment; /// The storage. typedef typename aligned_storage<_S_len, alignment_value>::type type; }; template const size_t aligned_union<_Len, _Types...>::alignment_value; // Decay trait for arrays and functions, used for perfect forwarding // in make_pair, make_tuple, etc. template::value, bool _IsFunction = is_function<_Up>::value> struct __decay_selector; // NB: DR 705. template struct __decay_selector<_Up, false, false> { typedef typename remove_cv<_Up>::type __type; }; template struct __decay_selector<_Up, true, false> { typedef typename remove_extent<_Up>::type* __type; }; template struct __decay_selector<_Up, false, true> { typedef typename add_pointer<_Up>::type __type; }; /// decay template class decay { typedef typename remove_reference<_Tp>::type __remove_type; public: typedef typename __decay_selector<__remove_type>::__type type; }; template class reference_wrapper; // Helper which adds a reference to a type when given a reference_wrapper template struct __strip_reference_wrapper { typedef _Tp __type; }; template struct __strip_reference_wrapper > { typedef _Tp& __type; }; template struct __decay_and_strip { typedef typename __strip_reference_wrapper< typename decay<_Tp>::type>::__type __type; }; // Primary template. /// Define a member typedef @c type only if a boolean constant is true. template struct enable_if { }; // Partial specialization for true. template struct enable_if { typedef _Tp type; }; template using _Require = typename enable_if<__and_<_Cond...>::value>::type; // Primary template. /// Define a member typedef @c type to one of two argument types. template struct conditional { typedef _Iftrue type; }; // Partial specialization for false. template struct conditional { typedef _Iffalse type; }; /// common_type template struct common_type; // Sfinae-friendly common_type implementation: struct __do_common_type_impl { template static __success_type() : std::declval<_Up>())>::type> _S_test(int); template static __failure_type _S_test(...); }; template struct __common_type_impl : private __do_common_type_impl { typedef decltype(_S_test<_Tp, _Up>(0)) type; }; struct __do_member_type_wrapper { template static __success_type _S_test(int); template static __failure_type _S_test(...); }; template struct __member_type_wrapper : private __do_member_type_wrapper { typedef decltype(_S_test<_Tp>(0)) type; }; template struct __expanded_common_type_wrapper { typedef common_type type; }; template struct __expanded_common_type_wrapper<__failure_type, _Args...> { typedef __failure_type type; }; template<> struct common_type<> { }; template struct common_type<_Tp> : common_type<_Tp, _Tp> { }; template struct common_type<_Tp, _Up> : public __common_type_impl<_Tp, _Up>::type { }; template struct common_type<_Tp, _Up, _Vp...> : public __expanded_common_type_wrapper>::type, _Vp...>::type { }; /// The underlying type of an enum. template struct underlying_type { typedef __underlying_type(_Tp) type; }; template struct __declval_protector { static const bool __stop = false; }; template auto declval() noexcept -> decltype(__declval<_Tp>(0)) { static_assert(__declval_protector<_Tp>::__stop, "declval() must not be used!"); return __declval<_Tp>(0); } // wchar_t, char16_t and char32_t are integral types but are neither // signed integer types nor unsigned integer types, so must be // transformed to the integer type with the smallest rank that has the // same size and signedness. // Use the partial specialization for enumeration types to do that, // which means these explicit specializations must be defined after // std::conditional has been defined. #if defined(_GLIBCXX_USE_WCHAR_T) template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; #endif template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; /// result_of template class result_of; // Sfinae-friendly result_of implementation: #define __cpp_lib_result_of_sfinae 201210 struct __invoke_memfun_ref { }; struct __invoke_memfun_deref { }; struct __invoke_memobj_ref { }; struct __invoke_memobj_deref { }; struct __invoke_other { }; // Associate a tag type with a specialization of __success_type. template struct __result_of_success : __success_type<_Tp> { using __invoke_type = _Tag; }; // [func.require] paragraph 1 bullet 1: struct __result_of_memfun_ref_impl { template static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; }; // [func.require] paragraph 1 bullet 2: struct __result_of_memfun_deref_impl { template static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; }; // [func.require] paragraph 1 bullet 3: struct __result_of_memobj_ref_impl { template static __result_of_success().*std::declval<_Fp>() ), __invoke_memobj_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; }; // [func.require] paragraph 1 bullet 4: struct __result_of_memobj_deref_impl { template static __result_of_success()).*std::declval<_Fp>() ), __invoke_memobj_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; }; template struct __result_of_memobj; template struct __result_of_memobj<_Res _Class::*, _Arg> { typedef typename remove_cv::type>::type _Argval; typedef _Res _Class::* _MemPtr; typedef typename conditional<__or_, is_base_of<_Class, _Argval>>::value, __result_of_memobj_ref<_MemPtr, _Arg>, __result_of_memobj_deref<_MemPtr, _Arg> >::type::type type; }; template struct __result_of_memfun; template struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> { typedef typename remove_cv::type>::type _Argval; typedef _Res _Class::* _MemPtr; typedef typename conditional<__or_, is_base_of<_Class, _Argval>>::value, __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, __result_of_memfun_deref<_MemPtr, _Arg, _Args...> >::type::type type; }; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 2219. INVOKE-ing a pointer to member with a reference_wrapper // as the object expression // Used by result_of, invoke etc. to unwrap a reference_wrapper. template::type> struct __inv_unwrap { using type = _Tp; }; template struct __inv_unwrap<_Tp, reference_wrapper<_Up>> { using type = _Up&; }; template struct __result_of_impl { typedef __failure_type type; }; template struct __result_of_impl : public __result_of_memobj::type, typename __inv_unwrap<_Arg>::type> { }; template struct __result_of_impl : public __result_of_memfun::type, typename __inv_unwrap<_Arg>::type, _Args...> { }; // [func.require] paragraph 1 bullet 5: struct __result_of_other_impl { template static __result_of_success()(std::declval<_Args>()...) ), __invoke_other> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_impl : private __result_of_other_impl { typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; }; // __invoke_result (std::invoke_result for C++11) template struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference<_Functor>::type >::value, is_member_function_pointer< typename remove_reference<_Functor>::type >::value, _Functor, _ArgTypes... >::type { }; template struct result_of<_Functor(_ArgTypes...)> : public __invoke_result<_Functor, _ArgTypes...> { }; #if __cplusplus >= 201402L /// Alias template for aligned_storage template::__type)> using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; template using aligned_union_t = typename aligned_union<_Len, _Types...>::type; /// Alias template for decay template using decay_t = typename decay<_Tp>::type; /// Alias template for enable_if template using enable_if_t = typename enable_if<_Cond, _Tp>::type; /// Alias template for conditional template using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; /// Alias template for common_type template using common_type_t = typename common_type<_Tp...>::type; /// Alias template for underlying_type template using underlying_type_t = typename underlying_type<_Tp>::type; /// Alias template for result_of template using result_of_t = typename result_of<_Tp>::type; #endif // C++14 // __enable_if_t (std::enable_if_t for C++11) template using __enable_if_t = typename enable_if<_Cond, _Tp>::type; // __void_t (std::void_t for C++11) template using __void_t = void; #if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11 #define __cpp_lib_void_t 201411 /// A metafunction that always yields void, used for detecting valid types. template using void_t = void; #endif /// Implementation of the detection idiom (negative case). template class _Op, typename... _Args> struct __detector { using value_t = false_type; using type = _Default; }; /// Implementation of the detection idiom (positive case). template class _Op, typename... _Args> struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> { using value_t = true_type; using type = _Op<_Args...>; }; // Detect whether _Op<_Args...> is a valid type, use _Default if not. template class _Op, typename... _Args> using __detected_or = __detector<_Default, void, _Op, _Args...>; // _Op<_Args...> if that is a valid type, otherwise _Default. template class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type; /// @} group metaprogramming /** * Use SFINAE to determine if the type _Tp has a publicly-accessible * member type _NTYPE. */ #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \ template> \ struct __has_##_NTYPE \ : false_type \ { }; \ template \ struct __has_##_NTYPE<_Tp, __void_t> \ : true_type \ { }; template struct __is_swappable; template struct __is_nothrow_swappable; template class tuple; template struct __is_tuple_like_impl : false_type { }; template struct __is_tuple_like_impl> : true_type { }; // Internal type trait that allows us to sfinae-protect tuple_cat. template struct __is_tuple_like : public __is_tuple_like_impl::type>::type>::type { }; template inline typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value>::type swap(_Tp&, _Tp&) noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value); template inline typename enable_if<__is_swappable<_Tp>::value>::type swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) noexcept(__is_nothrow_swappable<_Tp>::value); namespace __swappable_details { using std::swap; struct __do_is_swappable_impl { template(), std::declval<_Tp&>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) > __test(int); template static false_type __test(...); }; } // namespace __swappable_details template struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { typedef decltype(__test<_Tp>(0)) type; }; template struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { typedef decltype(__test<_Tp>(0)) type; }; template struct __is_swappable : public __is_swappable_impl<_Tp>::type { }; template struct __is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { }; #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 #define __cpp_lib_is_swappable 201603 /// Metafunctions used for detecting swappable types: p0185r1 /// is_swappable template struct is_swappable : public __is_swappable_impl<_Tp>::type { }; /// is_nothrow_swappable template struct is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { }; #if __cplusplus >= 201402L /// is_swappable_v template _GLIBCXX17_INLINE constexpr bool is_swappable_v = is_swappable<_Tp>::value; /// is_nothrow_swappable_v template _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value; #endif // __cplusplus >= 201402L namespace __swappable_with_details { using std::swap; struct __do_is_swappable_with_impl { template(), std::declval<_Up>())), typename = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_with_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) && noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) > __test(int); template static false_type __test(...); }; } // namespace __swappable_with_details template struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { typedef decltype(__test<_Tp, _Up>(0)) type; }; // Optimization for the homogenous lvalue case, not required: template struct __is_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_swappable_impl { typedef decltype(__test<_Tp&>(0)) type; }; template struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { typedef decltype(__test<_Tp, _Up>(0)) type; }; // Optimization for the homogenous lvalue case, not required: template struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_nothrow_swappable_impl { typedef decltype(__test<_Tp&>(0)) type; }; /// is_swappable_with template struct is_swappable_with : public __is_swappable_with_impl<_Tp, _Up>::type { }; /// is_nothrow_swappable_with template struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type { }; #if __cplusplus >= 201402L /// is_swappable_with_v template _GLIBCXX17_INLINE constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; /// is_nothrow_swappable_with_v template _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value; #endif // __cplusplus >= 201402L #endif// c++1z or gnu++11 // __is_invocable (std::is_invocable for C++11) template struct __is_invocable_impl : false_type { }; template struct __is_invocable_impl<_Result, _Ret, __void_t> : __or_, is_convertible>::type { }; template struct __is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type { }; template constexpr bool __call_is_nt(__invoke_memfun_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept((std::declval<_Up>().*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memfun_deref) { return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memobj_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept(std::declval<_Up>().*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_memobj_deref) { return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_other) { return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); } template struct __call_is_nothrow : __bool_constant< std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) > { }; template using __call_is_nothrow_ = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; // __is_nothrow_invocable (std::is_nothrow_invocable for C++11) template struct __is_nothrow_invocable : __and_<__is_invocable<_Fn, _Args...>, __call_is_nothrow_<_Fn, _Args...>>::type { }; struct __nonesuch { __nonesuch() = delete; ~__nonesuch() = delete; __nonesuch(__nonesuch const&) = delete; void operator=(__nonesuch const&) = delete; }; #if __cplusplus >= 201703L # define __cpp_lib_is_invocable 201703 /// std::invoke_result template struct invoke_result : public __invoke_result<_Functor, _ArgTypes...> { }; /// std::invoke_result_t template using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; /// std::is_invocable template struct is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type { }; /// std::is_invocable_r template struct is_invocable_r : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type { }; /// std::is_nothrow_invocable template struct is_nothrow_invocable : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type { }; template struct __is_nt_invocable_impl : false_type { }; template struct __is_nt_invocable_impl<_Result, _Ret, __void_t> : __or_, __and_, is_nothrow_constructible<_Ret, typename _Result::type>>> { }; /// std::is_nothrow_invocable_r template struct is_nothrow_invocable_r : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type { }; /// std::is_invocable_v template inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; /// std::is_nothrow_invocable_v template inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value; /// std::is_invocable_r_v template inline constexpr bool is_invocable_r_v = is_invocable_r<_Fn, _Args...>::value; /// std::is_nothrow_invocable_r_v template inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Fn, _Args...>::value; #endif // C++17 #if __cplusplus >= 201703L # define __cpp_lib_type_trait_variable_templates 201510L template inline constexpr bool is_void_v = is_void<_Tp>::value; template inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; template inline constexpr bool is_integral_v = is_integral<_Tp>::value; template inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; template inline constexpr bool is_array_v = is_array<_Tp>::value; template inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; template inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; template inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value; template inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; template inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; template inline constexpr bool is_enum_v = is_enum<_Tp>::value; template inline constexpr bool is_union_v = is_union<_Tp>::value; template inline constexpr bool is_class_v = is_class<_Tp>::value; template inline constexpr bool is_function_v = is_function<_Tp>::value; template inline constexpr bool is_reference_v = is_reference<_Tp>::value; template inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; template inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; template inline constexpr bool is_object_v = is_object<_Tp>::value; template inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; template inline constexpr bool is_compound_v = is_compound<_Tp>::value; template inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; template inline constexpr bool is_const_v = is_const<_Tp>::value; template inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; template inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; template inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value; template inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; template inline constexpr bool is_pod_v = is_pod<_Tp>::value; template inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; template inline constexpr bool is_empty_v = is_empty<_Tp>::value; template inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; template inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; template inline constexpr bool is_final_v = is_final<_Tp>::value; template inline constexpr bool is_signed_v = is_signed<_Tp>::value; template inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; template inline constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value; template inline constexpr bool is_default_constructible_v = is_default_constructible<_Tp>::value; template inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; template inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value; template inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; template inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; template inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; template inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; template inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Tp, _Args...>::value; template inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Tp>::value; template inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value; template inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value; template inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Tp, _Up>::value; template inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; template inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; template inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; template inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value; template inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Tp>::value; template inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value; template inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value; template inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Tp, _Up>::value; template inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; template inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; template inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; template inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value; template inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; template inline constexpr size_t rank_v = rank<_Tp>::value; template inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; template inline constexpr bool is_same_v = is_same<_Tp, _Up>::value; template inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; template inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; #if __GNUC__ >= 7 # define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1 #elif defined(__is_identifier) // For non-GNU compilers: # if ! __is_identifier(__has_unique_object_representations) # define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1 # endif #endif #ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP # define __cpp_lib_has_unique_object_representations 201606 /// has_unique_object_representations template struct has_unique_object_representations : bool_constant<__has_unique_object_representations( remove_cv_t> )> { }; template inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value; #endif #undef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP #if __GNUC__ >= 7 # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1 #elif defined(__is_identifier) // For non-GNU compilers: # if ! __is_identifier(__is_aggregate) # define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1 # endif #endif #ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE #define __cpp_lib_is_aggregate 201703 /// is_aggregate template struct is_aggregate : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { }; /// is_aggregate_v template inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value; #endif #undef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE #endif // C++17 #if __cplusplus > 201703L /// Byte order enum class endian { little = __ORDER_LITTLE_ENDIAN__, big = __ORDER_BIG_ENDIAN__, native = __BYTE_ORDER__ }; #endif // C++2a _GLIBCXX_END_NAMESPACE_VERSION } // namespace std #endif // C++11 #endif // _GLIBCXX_TYPE_TRAITS c++/8/ext/cmath000064400000014652152640040230007106 0ustar00// Math extensions -*- C++ -*- // Copyright (C) 2013-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/cmath * This file is a GNU extension to the Standard C++ Library. */ #ifndef _EXT_CMATH #define _EXT_CMATH 1 #pragma GCC system_header #if __cplusplus < 201103L # include #else #include #include namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // A class for math constants. template struct __math_constants { static_assert(std::is_floating_point<_RealType>::value, "template argument not a floating point type"); // Constant @f$ \pi @f$. static constexpr _RealType __pi = 3.1415926535897932384626433832795029L; // Constant @f$ \pi / 2 @f$. static constexpr _RealType __pi_half = 1.5707963267948966192313216916397514L; // Constant @f$ \pi / 3 @f$. static constexpr _RealType __pi_third = 1.0471975511965977461542144610931676L; // Constant @f$ \pi / 4 @f$. static constexpr _RealType __pi_quarter = 0.7853981633974483096156608458198757L; // Constant @f$ \sqrt(\pi / 2) @f$. static constexpr _RealType __root_pi_div_2 = 1.2533141373155002512078826424055226L; // Constant @f$ 1 / \pi @f$. static constexpr _RealType __one_div_pi = 0.3183098861837906715377675267450287L; // Constant @f$ 2 / \pi @f$. static constexpr _RealType __two_div_pi = 0.6366197723675813430755350534900574L; // Constant @f$ 2 / \sqrt(\pi) @f$. static constexpr _RealType __two_div_root_pi = 1.1283791670955125738961589031215452L; // Constant Euler's number @f$ e @f$. static constexpr _RealType __e = 2.7182818284590452353602874713526625L; // Constant @f$ 1 / e @f$. static constexpr _RealType __one_div_e = 0.36787944117144232159552377016146087L; // Constant @f$ \log_2(e) @f$. static constexpr _RealType __log2_e = 1.4426950408889634073599246810018921L; // Constant @f$ \log_10(e) @f$. static constexpr _RealType __log10_e = 0.4342944819032518276511289189166051L; // Constant @f$ \ln(2) @f$. static constexpr _RealType __ln_2 = 0.6931471805599453094172321214581766L; // Constant @f$ \ln(3) @f$. static constexpr _RealType __ln_3 = 1.0986122886681096913952452369225257L; // Constant @f$ \ln(10) @f$. static constexpr _RealType __ln_10 = 2.3025850929940456840179914546843642L; // Constant Euler-Mascheroni @f$ \gamma_E @f$. static constexpr _RealType __gamma_e = 0.5772156649015328606065120900824024L; // Constant Golden Ratio @f$ \phi @f$. static constexpr _RealType __phi = 1.6180339887498948482045868343656381L; // Constant @f$ \sqrt(2) @f$. static constexpr _RealType __root_2 = 1.4142135623730950488016887242096981L; // Constant @f$ \sqrt(3) @f$. static constexpr _RealType __root_3 = 1.7320508075688772935274463415058724L; // Constant @f$ \sqrt(5) @f$. static constexpr _RealType __root_5 = 2.2360679774997896964091736687312762L; // Constant @f$ \sqrt(7) @f$. static constexpr _RealType __root_7 = 2.6457513110645905905016157536392604L; // Constant @f$ 1 / \sqrt(2) @f$. static constexpr _RealType __one_div_root_2 = 0.7071067811865475244008443621048490L; }; // And the template definitions for the constants. template constexpr _RealType __math_constants<_RealType>::__pi; template constexpr _RealType __math_constants<_RealType>::__pi_half; template constexpr _RealType __math_constants<_RealType>::__pi_third; template constexpr _RealType __math_constants<_RealType>::__pi_quarter; template constexpr _RealType __math_constants<_RealType>::__root_pi_div_2; template constexpr _RealType __math_constants<_RealType>::__one_div_pi; template constexpr _RealType __math_constants<_RealType>::__two_div_pi; template constexpr _RealType __math_constants<_RealType>::__two_div_root_pi; template constexpr _RealType __math_constants<_RealType>::__e; template constexpr _RealType __math_constants<_RealType>::__one_div_e; template constexpr _RealType __math_constants<_RealType>::__log2_e; template constexpr _RealType __math_constants<_RealType>::__log10_e; template constexpr _RealType __math_constants<_RealType>::__ln_2; template constexpr _RealType __math_constants<_RealType>::__ln_3; template constexpr _RealType __math_constants<_RealType>::__ln_10; template constexpr _RealType __math_constants<_RealType>::__gamma_e; template constexpr _RealType __math_constants<_RealType>::__phi; template constexpr _RealType __math_constants<_RealType>::__root_2; template constexpr _RealType __math_constants<_RealType>::__root_3; template constexpr _RealType __math_constants<_RealType>::__root_5; template constexpr _RealType __math_constants<_RealType>::__root_7; template constexpr _RealType __math_constants<_RealType>::__one_div_root_2; _GLIBCXX_END_NAMESPACE_VERSION } // namespace __gnu_cxx #endif // C++11 #endif // _EXT_CMATH c++/8/ext/stdio_sync_filebuf.h000064400000021116152640040230012103 0ustar00// Iostreams wrapper for stdio FILE* -*- C++ -*- // Copyright (C) 2003-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/stdio_sync_filebuf.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _STDIO_SYNC_FILEBUF_H #define _STDIO_SYNC_FILEBUF_H 1 #pragma GCC system_header #include #include #include #include // For __c_file #include // For __exchange #ifdef _GLIBCXX_USE_WCHAR_T #include #endif namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @brief Provides a layer of compatibility for C. * @ingroup io * * This GNU extension provides extensions for working with standard * C FILE*'s. It must be instantiated by the user with the type of * character used in the file stream, e.g., stdio_filebuf. */ template > class stdio_sync_filebuf : public std::basic_streambuf<_CharT, _Traits> { public: // Types: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; private: typedef std::basic_streambuf<_CharT, _Traits> __streambuf_type; // Underlying stdio FILE std::__c_file* _M_file; // Last character gotten. This is used when pbackfail is // called from basic_streambuf::sungetc() int_type _M_unget_buf; public: explicit stdio_sync_filebuf(std::__c_file* __f) : _M_file(__f), _M_unget_buf(traits_type::eof()) { } #if __cplusplus >= 201103L stdio_sync_filebuf(stdio_sync_filebuf&& __fb) noexcept : __streambuf_type(std::move(__fb)), _M_file(__fb._M_file), _M_unget_buf(__fb._M_unget_buf) { __fb._M_file = nullptr; __fb._M_unget_buf = traits_type::eof(); } stdio_sync_filebuf& operator=(stdio_sync_filebuf&& __fb) noexcept { __streambuf_type::operator=(__fb); _M_file = std::__exchange(__fb._M_file, nullptr); _M_unget_buf = std::__exchange(__fb._M_unget_buf, traits_type::eof()); return *this; } void swap(stdio_sync_filebuf& __fb) { __streambuf_type::swap(__fb); std::swap(_M_file, __fb._M_file); std::swap(_M_unget_buf, __fb._M_unget_buf); } #endif /** * @return The underlying FILE*. * * This function can be used to access the underlying C file pointer. * Note that there is no way for the library to track what you do * with the file, so be careful. */ std::__c_file* file() { return this->_M_file; } protected: int_type syncgetc(); int_type syncungetc(int_type __c); int_type syncputc(int_type __c); virtual int_type underflow() { int_type __c = this->syncgetc(); return this->syncungetc(__c); } virtual int_type uflow() { // Store the gotten character in case we need to unget it. _M_unget_buf = this->syncgetc(); return _M_unget_buf; } virtual int_type pbackfail(int_type __c = traits_type::eof()) { int_type __ret; const int_type __eof = traits_type::eof(); // Check if the unget or putback was requested if (traits_type::eq_int_type(__c, __eof)) // unget { if (!traits_type::eq_int_type(_M_unget_buf, __eof)) __ret = this->syncungetc(_M_unget_buf); else // buffer invalid, fail. __ret = __eof; } else // putback __ret = this->syncungetc(__c); // The buffered character is no longer valid, discard it. _M_unget_buf = __eof; return __ret; } virtual std::streamsize xsgetn(char_type* __s, std::streamsize __n); virtual int_type overflow(int_type __c = traits_type::eof()) { int_type __ret; if (traits_type::eq_int_type(__c, traits_type::eof())) { if (std::fflush(_M_file)) __ret = traits_type::eof(); else __ret = traits_type::not_eof(__c); } else __ret = this->syncputc(__c); return __ret; } virtual std::streamsize xsputn(const char_type* __s, std::streamsize __n); virtual int sync() { return std::fflush(_M_file); } virtual std::streampos seekoff(std::streamoff __off, std::ios_base::seekdir __dir, std::ios_base::openmode = std::ios_base::in | std::ios_base::out) { std::streampos __ret(std::streamoff(-1)); int __whence; if (__dir == std::ios_base::beg) __whence = SEEK_SET; else if (__dir == std::ios_base::cur) __whence = SEEK_CUR; else __whence = SEEK_END; #ifdef _GLIBCXX_USE_LFS if (!fseeko64(_M_file, __off, __whence)) __ret = std::streampos(ftello64(_M_file)); #else if (!fseek(_M_file, __off, __whence)) __ret = std::streampos(std::ftell(_M_file)); #endif return __ret; } virtual std::streampos seekpos(std::streampos __pos, std::ios_base::openmode __mode = std::ios_base::in | std::ios_base::out) { return seekoff(std::streamoff(__pos), std::ios_base::beg, __mode); } }; template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncgetc() { return std::getc(_M_file); } template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncungetc(int_type __c) { return std::ungetc(__c, _M_file); } template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncputc(int_type __c) { return std::putc(__c, _M_file); } template<> inline std::streamsize stdio_sync_filebuf::xsgetn(char* __s, std::streamsize __n) { std::streamsize __ret = std::fread(__s, 1, __n, _M_file); if (__ret > 0) _M_unget_buf = traits_type::to_int_type(__s[__ret - 1]); else _M_unget_buf = traits_type::eof(); return __ret; } template<> inline std::streamsize stdio_sync_filebuf::xsputn(const char* __s, std::streamsize __n) { return std::fwrite(__s, 1, __n, _M_file); } #ifdef _GLIBCXX_USE_WCHAR_T template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncgetc() { return std::getwc(_M_file); } template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncungetc(int_type __c) { return std::ungetwc(__c, _M_file); } template<> inline stdio_sync_filebuf::int_type stdio_sync_filebuf::syncputc(int_type __c) { return std::putwc(__c, _M_file); } template<> inline std::streamsize stdio_sync_filebuf::xsgetn(wchar_t* __s, std::streamsize __n) { std::streamsize __ret = 0; const int_type __eof = traits_type::eof(); while (__n--) { int_type __c = this->syncgetc(); if (traits_type::eq_int_type(__c, __eof)) break; __s[__ret] = traits_type::to_char_type(__c); ++__ret; } if (__ret > 0) _M_unget_buf = traits_type::to_int_type(__s[__ret - 1]); else _M_unget_buf = traits_type::eof(); return __ret; } template<> inline std::streamsize stdio_sync_filebuf::xsputn(const wchar_t* __s, std::streamsize __n) { std::streamsize __ret = 0; const int_type __eof = traits_type::eof(); while (__n--) { if (traits_type::eq_int_type(this->syncputc(*__s++), __eof)) break; ++__ret; } return __ret; } #endif #if _GLIBCXX_EXTERN_TEMPLATE extern template class stdio_sync_filebuf; #ifdef _GLIBCXX_USE_WCHAR_T extern template class stdio_sync_filebuf; #endif #endif _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif c++/8/ext/sso_string_base.h000064400000037672152640040230011433 0ustar00// Short-string-optimized versatile string base -*- C++ -*- // Copyright (C) 2005-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/sso_string_base.h * This is an internal header file, included by other library headers. * Do not attempt to use it directly. @headername{ext/vstring.h} */ #ifndef _SSO_STRING_BASE_H #define _SSO_STRING_BASE_H 1 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION template class __sso_string_base : protected __vstring_utility<_CharT, _Traits, _Alloc> { public: typedef _Traits traits_type; typedef typename _Traits::char_type value_type; typedef __vstring_utility<_CharT, _Traits, _Alloc> _Util_Base; typedef typename _Util_Base::_CharT_alloc_type _CharT_alloc_type; typedef typename _CharT_alloc_type::size_type size_type; private: // Data Members: typename _Util_Base::template _Alloc_hider<_CharT_alloc_type> _M_dataplus; size_type _M_string_length; enum { _S_local_capacity = 15 }; union { _CharT _M_local_data[_S_local_capacity + 1]; size_type _M_allocated_capacity; }; void _M_data(_CharT* __p) { _M_dataplus._M_p = __p; } void _M_length(size_type __length) { _M_string_length = __length; } void _M_capacity(size_type __capacity) { _M_allocated_capacity = __capacity; } bool _M_is_local() const { return _M_data() == _M_local_data; } // Create & Destroy _CharT* _M_create(size_type&, size_type); void _M_dispose() { if (!_M_is_local()) _M_destroy(_M_allocated_capacity); } void _M_destroy(size_type __size) throw() { _M_get_allocator().deallocate(_M_data(), __size + 1); } // _M_construct_aux is used to implement the 21.3.1 para 15 which // requires special behaviour if _InIterator is an integral type template void _M_construct_aux(_InIterator __beg, _InIterator __end, std::__false_type) { typedef typename iterator_traits<_InIterator>::iterator_category _Tag; _M_construct(__beg, __end, _Tag()); } // _GLIBCXX_RESOLVE_LIB_DEFECTS // 438. Ambiguity in the "do the right thing" clause template void _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type) { _M_construct_aux_2(static_cast(__beg), __end); } void _M_construct_aux_2(size_type __req, _CharT __c) { _M_construct(__req, __c); } template void _M_construct(_InIterator __beg, _InIterator __end) { typedef typename std::__is_integer<_InIterator>::__type _Integral; _M_construct_aux(__beg, __end, _Integral()); } // For Input Iterators, used in istreambuf_iterators, etc. template void _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag); // For forward_iterators up to random_access_iterators, used for // string::iterator, _CharT*, etc. template void _M_construct(_FwdIterator __beg, _FwdIterator __end, std::forward_iterator_tag); void _M_construct(size_type __req, _CharT __c); public: size_type _M_max_size() const { return (_M_get_allocator().max_size() - 1) / 2; } _CharT* _M_data() const { return _M_dataplus._M_p; } size_type _M_length() const { return _M_string_length; } size_type _M_capacity() const { return _M_is_local() ? size_type(_S_local_capacity) : _M_allocated_capacity; } bool _M_is_shared() const { return false; } void _M_set_leaked() { } void _M_leak() { } void _M_set_length(size_type __n) { _M_length(__n); traits_type::assign(_M_data()[__n], _CharT()); } __sso_string_base() : _M_dataplus(_M_local_data) { _M_set_length(0); } __sso_string_base(const _Alloc& __a); __sso_string_base(const __sso_string_base& __rcs); #if __cplusplus >= 201103L __sso_string_base(__sso_string_base&& __rcs); #endif __sso_string_base(size_type __n, _CharT __c, const _Alloc& __a); template __sso_string_base(_InputIterator __beg, _InputIterator __end, const _Alloc& __a); ~__sso_string_base() { _M_dispose(); } _CharT_alloc_type& _M_get_allocator() { return _M_dataplus; } const _CharT_alloc_type& _M_get_allocator() const { return _M_dataplus; } void _M_swap(__sso_string_base& __rcs); void _M_assign(const __sso_string_base& __rcs); void _M_reserve(size_type __res); void _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2); void _M_erase(size_type __pos, size_type __n); void _M_clear() { _M_set_length(0); } bool _M_compare(const __sso_string_base&) const { return false; } }; template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_swap(__sso_string_base& __rcs) { if (this == &__rcs) return; // _GLIBCXX_RESOLVE_LIB_DEFECTS // 431. Swapping containers with unequal allocators. std::__alloc_swap<_CharT_alloc_type>::_S_do_it(_M_get_allocator(), __rcs._M_get_allocator()); if (_M_is_local()) if (__rcs._M_is_local()) { if (_M_length() && __rcs._M_length()) { _CharT __tmp_data[_S_local_capacity + 1]; traits_type::copy(__tmp_data, __rcs._M_local_data, _S_local_capacity + 1); traits_type::copy(__rcs._M_local_data, _M_local_data, _S_local_capacity + 1); traits_type::copy(_M_local_data, __tmp_data, _S_local_capacity + 1); } else if (__rcs._M_length()) { traits_type::copy(_M_local_data, __rcs._M_local_data, _S_local_capacity + 1); _M_length(__rcs._M_length()); __rcs._M_set_length(0); return; } else if (_M_length()) { traits_type::copy(__rcs._M_local_data, _M_local_data, _S_local_capacity + 1); __rcs._M_length(_M_length()); _M_set_length(0); return; } } else { const size_type __tmp_capacity = __rcs._M_allocated_capacity; traits_type::copy(__rcs._M_local_data, _M_local_data, _S_local_capacity + 1); _M_data(__rcs._M_data()); __rcs._M_data(__rcs._M_local_data); _M_capacity(__tmp_capacity); } else { const size_type __tmp_capacity = _M_allocated_capacity; if (__rcs._M_is_local()) { traits_type::copy(_M_local_data, __rcs._M_local_data, _S_local_capacity + 1); __rcs._M_data(_M_data()); _M_data(_M_local_data); } else { _CharT* __tmp_ptr = _M_data(); _M_data(__rcs._M_data()); __rcs._M_data(__tmp_ptr); _M_capacity(__rcs._M_allocated_capacity); } __rcs._M_capacity(__tmp_capacity); } const size_type __tmp_length = _M_length(); _M_length(__rcs._M_length()); __rcs._M_length(__tmp_length); } template _CharT* __sso_string_base<_CharT, _Traits, _Alloc>:: _M_create(size_type& __capacity, size_type __old_capacity) { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 83. String::npos vs. string::max_size() if (__capacity > _M_max_size()) std::__throw_length_error(__N("__sso_string_base::_M_create")); // The below implements an exponential growth policy, necessary to // meet amortized linear time requirements of the library: see // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html. if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) { __capacity = 2 * __old_capacity; // Never allocate a string bigger than max_size. if (__capacity > _M_max_size()) __capacity = _M_max_size(); } // NB: Need an array of char_type[__capacity], plus a terminating // null char_type() element. return _M_get_allocator().allocate(__capacity + 1); } template __sso_string_base<_CharT, _Traits, _Alloc>:: __sso_string_base(const _Alloc& __a) : _M_dataplus(__a, _M_local_data) { _M_set_length(0); } template __sso_string_base<_CharT, _Traits, _Alloc>:: __sso_string_base(const __sso_string_base& __rcs) : _M_dataplus(__rcs._M_get_allocator(), _M_local_data) { _M_construct(__rcs._M_data(), __rcs._M_data() + __rcs._M_length()); } #if __cplusplus >= 201103L template __sso_string_base<_CharT, _Traits, _Alloc>:: __sso_string_base(__sso_string_base&& __rcs) : _M_dataplus(__rcs._M_get_allocator(), _M_local_data) { if (__rcs._M_is_local()) { if (__rcs._M_length()) traits_type::copy(_M_local_data, __rcs._M_local_data, _S_local_capacity + 1); } else { _M_data(__rcs._M_data()); _M_capacity(__rcs._M_allocated_capacity); } _M_set_length(__rcs._M_length()); __rcs._M_data(__rcs._M_local_data); __rcs._M_set_length(0); } #endif template __sso_string_base<_CharT, _Traits, _Alloc>:: __sso_string_base(size_type __n, _CharT __c, const _Alloc& __a) : _M_dataplus(__a, _M_local_data) { _M_construct(__n, __c); } template template __sso_string_base<_CharT, _Traits, _Alloc>:: __sso_string_base(_InputIterator __beg, _InputIterator __end, const _Alloc& __a) : _M_dataplus(__a, _M_local_data) { _M_construct(__beg, __end); } // NB: This is the special case for Input Iterators, used in // istreambuf_iterators, etc. // Input Iterators have a cost structure very different from // pointers, calling for a different coding style. template template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag) { size_type __len = 0; size_type __capacity = size_type(_S_local_capacity); while (__beg != __end && __len < __capacity) { _M_data()[__len++] = *__beg; ++__beg; } __try { while (__beg != __end) { if (__len == __capacity) { // Allocate more space. __capacity = __len + 1; _CharT* __another = _M_create(__capacity, __len); this->_S_copy(__another, _M_data(), __len); _M_dispose(); _M_data(__another); _M_capacity(__capacity); } _M_data()[__len++] = *__beg; ++__beg; } } __catch(...) { _M_dispose(); __throw_exception_again; } _M_set_length(__len); } template template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::forward_iterator_tag) { // NB: Not required, but considered best practice. if (__is_null_pointer(__beg) && __beg != __end) std::__throw_logic_error(__N("__sso_string_base::" "_M_construct null not valid")); size_type __dnew = static_cast(std::distance(__beg, __end)); if (__dnew > size_type(_S_local_capacity)) { _M_data(_M_create(__dnew, size_type(0))); _M_capacity(__dnew); } // Check for out_of_range and length_error exceptions. __try { this->_S_copy_chars(_M_data(), __beg, __end); } __catch(...) { _M_dispose(); __throw_exception_again; } _M_set_length(__dnew); } template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_construct(size_type __n, _CharT __c) { if (__n > size_type(_S_local_capacity)) { _M_data(_M_create(__n, size_type(0))); _M_capacity(__n); } if (__n) this->_S_assign(_M_data(), __n, __c); _M_set_length(__n); } template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_assign(const __sso_string_base& __rcs) { if (this != &__rcs) { const size_type __rsize = __rcs._M_length(); const size_type __capacity = _M_capacity(); if (__rsize > __capacity) { size_type __new_capacity = __rsize; _CharT* __tmp = _M_create(__new_capacity, __capacity); _M_dispose(); _M_data(__tmp); _M_capacity(__new_capacity); } if (__rsize) this->_S_copy(_M_data(), __rcs._M_data(), __rsize); _M_set_length(__rsize); } } template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_reserve(size_type __res) { // Make sure we don't shrink below the current size. if (__res < _M_length()) __res = _M_length(); const size_type __capacity = _M_capacity(); if (__res != __capacity) { if (__res > __capacity || __res > size_type(_S_local_capacity)) { _CharT* __tmp = _M_create(__res, __capacity); this->_S_copy(__tmp, _M_data(), _M_length() + 1); _M_dispose(); _M_data(__tmp); _M_capacity(__res); } else if (!_M_is_local()) { this->_S_copy(_M_local_data, _M_data(), _M_length() + 1); _M_destroy(__capacity); _M_data(_M_local_data); } } } template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2) { const size_type __how_much = _M_length() - __pos - __len1; size_type __new_capacity = _M_length() + __len2 - __len1; _CharT* __r = _M_create(__new_capacity, _M_capacity()); if (__pos) this->_S_copy(__r, _M_data(), __pos); if (__s && __len2) this->_S_copy(__r + __pos, __s, __len2); if (__how_much) this->_S_copy(__r + __pos + __len2, _M_data() + __pos + __len1, __how_much); _M_dispose(); _M_data(__r); _M_capacity(__new_capacity); } template void __sso_string_base<_CharT, _Traits, _Alloc>:: _M_erase(size_type __pos, size_type __n) { const size_type __how_much = _M_length() - __pos - __n; if (__how_much && __n) this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much); _M_set_length(_M_length() - __n); } _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif /* _SSO_STRING_BASE_H */ c++/8/ext/aligned_buffer.h000064400000007604152640040230011173 0ustar00// Aligned memory buffer -*- C++ -*- // Copyright (C) 2013-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/aligned_buffer.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _ALIGNED_BUFFER_H #define _ALIGNED_BUFFER_H 1 #pragma GCC system_header #if __cplusplus >= 201103L # include #else # include #endif namespace __gnu_cxx { // A utility type containing a POD object that can hold an object of type // _Tp initialized via placement new or allocator_traits::construct. // Intended for use as a data member subobject, use __aligned_buffer for // complete objects. template struct __aligned_membuf { // Target macro ADJUST_FIELD_ALIGN can produce different alignment for // types when used as class members. __aligned_membuf is intended // for use as a class member, so align the buffer as for a class member. // Since GCC 8 we could just use alignof(_Tp) instead, but older // versions of non-GNU compilers might still need this trick. struct _Tp2 { _Tp _M_t; }; alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; __aligned_membuf() = default; // Can be used to avoid value-initialization zeroing _M_storage. __aligned_membuf(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; #if _GLIBCXX_INLINE_VERSION template using __aligned_buffer = __aligned_membuf<_Tp>; #else // Similar to __aligned_membuf but aligned for complete objects, not members. // This type is used in , , // and , but ideally they would use __aligned_membuf // instead, as it has smaller size for some types on some targets. // This type is still used to avoid an ABI change. template struct __aligned_buffer : std::aligned_storage { typename std::aligned_storage::type _M_storage; __aligned_buffer() = default; // Can be used to avoid value-initialization __aligned_buffer(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; #endif } // namespace #endif /* _ALIGNED_BUFFER_H */ c++/8/ext/type_traits.h000064400000013432152640040230010602 0ustar00// -*- C++ -*- // Copyright (C) 2005-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms // of the GNU General Public License as published by the Free Software // Foundation; either version 3, or (at your option) any later // version. // This 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 // General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/type_traits.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _EXT_TYPE_TRAITS #define _EXT_TYPE_TRAITS 1 #pragma GCC system_header #include #include extern "C++" { namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Define a nested type if some predicate holds. template struct __enable_if { }; template struct __enable_if { typedef _Tp __type; }; // Conditional expression for types. If true, first, if false, second. template struct __conditional_type { typedef _Iftrue __type; }; template struct __conditional_type { typedef _Iffalse __type; }; // Given an integral builtin type, return the corresponding unsigned type. template struct __add_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned short __type; }; template<> struct __add_unsigned { typedef unsigned int __type; }; template<> struct __add_unsigned { typedef unsigned long __type; }; template<> struct __add_unsigned { typedef unsigned long long __type; }; // Declare but don't define. template<> struct __add_unsigned; template<> struct __add_unsigned; // Given an integral builtin type, return the corresponding signed type. template struct __remove_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef short __type; }; template<> struct __remove_unsigned { typedef int __type; }; template<> struct __remove_unsigned { typedef long __type; }; template<> struct __remove_unsigned { typedef long long __type; }; // Declare but don't define. template<> struct __remove_unsigned; template<> struct __remove_unsigned; // For use in string and vstring. template inline bool __is_null_pointer(_Type* __ptr) { return __ptr == 0; } template inline bool __is_null_pointer(_Type) { return false; } #if __cplusplus >= 201103L inline bool __is_null_pointer(std::nullptr_t) { return true; } #endif // For complex and cmath template::__value> struct __promote { typedef double __type; }; // No nested __type member for non-integer non-floating point types, // allows this type to be used for SFINAE to constrain overloads in // and to only the intended types. template struct __promote<_Tp, false> { }; template<> struct __promote { typedef long double __type; }; template<> struct __promote { typedef double __type; }; template<> struct __promote { typedef float __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type> struct __promote_2 { typedef __typeof__(_Tp2() + _Up2()) __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type> struct __promote_3 { typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type, typename _Wp2 = typename __promote<_Wp>::__type> struct __promote_4 { typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace } // extern "C++" #endif c++/8/ext/functional000064400000033724152640040230010155 0ustar00// Functional extensions -*- C++ -*- // Copyright (C) 2002-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1996 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /** @file ext/functional * This file is a GNU extension to the Standard C++ Library (possibly * containing extensions from the HP/SGI STL subset). */ #ifndef _EXT_FUNCTIONAL #define _EXT_FUNCTIONAL 1 #pragma GCC system_header #include namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION using std::size_t; using std::unary_function; using std::binary_function; using std::mem_fun1_t; using std::const_mem_fun1_t; using std::mem_fun1_ref_t; using std::const_mem_fun1_ref_t; /** The @c identity_element functions are not part of the C++ * standard; SGI provided them as an extension. Its argument is an * operation, and its return value is the identity element for that * operation. It is overloaded for addition and multiplication, * and you can overload it for your own nefarious operations. * * @addtogroup SGIextensions * @{ */ /// An \link SGIextensions SGI extension \endlink. template inline _Tp identity_element(std::plus<_Tp>) { return _Tp(0); } /// An \link SGIextensions SGI extension \endlink. template inline _Tp identity_element(std::multiplies<_Tp>) { return _Tp(1); } /** @} */ /** As an extension to the binders, SGI provided composition functors and * wrapper functions to aid in their creation. The @c unary_compose * functor is constructed from two functions/functors, @c f and @c g. * Calling @c operator() with a single argument @c x returns @c f(g(x)). * The function @c compose1 takes the two functions and constructs a * @c unary_compose variable for you. * * @c binary_compose is constructed from three functors, @c f, @c g1, * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function * compose2 takes f, g1, and g2, and constructs the @c binary_compose * instance for you. For example, if @c f returns an int, then * \code * int answer = (compose2(f,g1,g2))(x); * \endcode * is equivalent to * \code * int temp1 = g1(x); * int temp2 = g2(x); * int answer = f(temp1,temp2); * \endcode * But the first form is more compact, and can be passed around as a * functor to other algorithms. * * @addtogroup SGIextensions * @{ */ /// An \link SGIextensions SGI extension \endlink. template class unary_compose : public unary_function { protected: _Operation1 _M_fn1; _Operation2 _M_fn2; public: unary_compose(const _Operation1& __x, const _Operation2& __y) : _M_fn1(__x), _M_fn2(__y) {} typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { return _M_fn1(_M_fn2(__x)); } }; /// An \link SGIextensions SGI extension \endlink. template inline unary_compose<_Operation1, _Operation2> compose1(const _Operation1& __fn1, const _Operation2& __fn2) { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); } /// An \link SGIextensions SGI extension \endlink. template class binary_compose : public unary_function { protected: _Operation1 _M_fn1; _Operation2 _M_fn2; _Operation3 _M_fn3; public: binary_compose(const _Operation1& __x, const _Operation2& __y, const _Operation3& __z) : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { return _M_fn1(_M_fn2(__x), _M_fn3(__x)); } }; /// An \link SGIextensions SGI extension \endlink. template inline binary_compose<_Operation1, _Operation2, _Operation3> compose2(const _Operation1& __fn1, const _Operation2& __fn2, const _Operation3& __fn3) { return binary_compose<_Operation1, _Operation2, _Operation3> (__fn1, __fn2, __fn3); } /** @} */ /** As an extension, SGI provided a functor called @c identity. When a * functor is required but no operations are desired, this can be used as a * pass-through. Its @c operator() returns its argument unchanged. * * @addtogroup SGIextensions */ template struct identity : public std::_Identity<_Tp> {}; /** @c select1st and @c select2nd are extensions provided by SGI. Their * @c operator()s * take a @c std::pair as an argument, and return either the first member * or the second member, respectively. They can be used (especially with * the composition functors) to @a strip data from a sequence before * performing the remainder of an algorithm. * * @addtogroup SGIextensions * @{ */ /// An \link SGIextensions SGI extension \endlink. template struct select1st : public std::_Select1st<_Pair> {}; /// An \link SGIextensions SGI extension \endlink. template struct select2nd : public std::_Select2nd<_Pair> {}; /** @} */ // extension documented next template struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> { _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } }; template struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> { _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; } }; /** The @c operator() of the @c project1st functor takes two arbitrary * arguments and returns the first one, while @c project2nd returns the * second one. They are extensions provided by SGI. * * @addtogroup SGIextensions * @{ */ /// An \link SGIextensions SGI extension \endlink. template struct project1st : public _Project1st<_Arg1, _Arg2> {}; /// An \link SGIextensions SGI extension \endlink. template struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; /** @} */ // extension documented next template struct _Constant_void_fun { typedef _Result result_type; result_type _M_val; _Constant_void_fun(const result_type& __v) : _M_val(__v) {} const result_type& operator()() const { return _M_val; } }; template struct _Constant_unary_fun { typedef _Argument argument_type; typedef _Result result_type; result_type _M_val; _Constant_unary_fun(const result_type& __v) : _M_val(__v) {} const result_type& operator()(const _Argument&) const { return _M_val; } }; template struct _Constant_binary_fun { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; _Result _M_val; _Constant_binary_fun(const _Result& __v) : _M_val(__v) {} const result_type& operator()(const _Arg1&, const _Arg2&) const { return _M_val; } }; /** These three functors are each constructed from a single arbitrary * variable/value. Later, their @c operator()s completely ignore any * arguments passed, and return the stored value. * - @c constant_void_fun's @c operator() takes no arguments * - @c constant_unary_fun's @c operator() takes one argument (ignored) * - @c constant_binary_fun's @c operator() takes two arguments (ignored) * * The helper creator functions @c constant0, @c constant1, and * @c constant2 each take a @a result argument and construct variables of * the appropriate functor type. * * @addtogroup SGIextensions * @{ */ /// An \link SGIextensions SGI extension \endlink. template struct constant_void_fun : public _Constant_void_fun<_Result> { constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} }; /// An \link SGIextensions SGI extension \endlink. template struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> { constant_unary_fun(const _Result& __v) : _Constant_unary_fun<_Result, _Argument>(__v) {} }; /// An \link SGIextensions SGI extension \endlink. template struct constant_binary_fun : public _Constant_binary_fun<_Result, _Arg1, _Arg2> { constant_binary_fun(const _Result& __v) : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} }; /// An \link SGIextensions SGI extension \endlink. template inline constant_void_fun<_Result> constant0(const _Result& __val) { return constant_void_fun<_Result>(__val); } /// An \link SGIextensions SGI extension \endlink. template inline constant_unary_fun<_Result, _Result> constant1(const _Result& __val) { return constant_unary_fun<_Result, _Result>(__val); } /// An \link SGIextensions SGI extension \endlink. template inline constant_binary_fun<_Result,_Result,_Result> constant2(const _Result& __val) { return constant_binary_fun<_Result, _Result, _Result>(__val); } /** @} */ /** The @c subtractive_rng class is documented on * SGI's site. * Note that this code assumes that @c int is 32 bits. * * @ingroup SGIextensions */ class subtractive_rng : public unary_function { private: unsigned int _M_table[55]; size_t _M_index1; size_t _M_index2; public: /// Returns a number less than the argument. unsigned int operator()(unsigned int __limit) { _M_index1 = (_M_index1 + 1) % 55; _M_index2 = (_M_index2 + 1) % 55; _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; return _M_table[_M_index1] % __limit; } void _M_initialize(unsigned int __seed) { unsigned int __k = 1; _M_table[54] = __seed; size_t __i; for (__i = 0; __i < 54; __i++) { size_t __ii = (21 * (__i + 1) % 55) - 1; _M_table[__ii] = __k; __k = __seed - __k; __seed = _M_table[__ii]; } for (int __loop = 0; __loop < 4; __loop++) { for (__i = 0; __i < 55; __i++) _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; } _M_index1 = 0; _M_index2 = 31; } /// Ctor allowing you to initialize the seed. subtractive_rng(unsigned int __seed) { _M_initialize(__seed); } /// Default ctor; initializes its state with some number you don't see. subtractive_rng() { _M_initialize(161803398u); } }; // Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, // provided for backward compatibility, they are no longer part of // the C++ standard. template inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template inline const_mem_fun1_t<_Ret, _Tp, _Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template inline mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } template inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } _GLIBCXX_END_NAMESPACE_VERSION } // namespace #endif c++/8/ext/numeric_traits.h000064400000010737152640040230011270 0ustar00// -*- C++ -*- // Copyright (C) 2007-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms // of the GNU General Public License as published by the Free Software // Foundation; either version 3, or (at your option) any later // version. // This 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 // General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/numeric_traits.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _EXT_NUMERIC_TRAITS #define _EXT_NUMERIC_TRAITS 1 #pragma GCC system_header #include #include namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION // Compile time constants for builtin types. // Sadly std::numeric_limits member functions cannot be used for this. #define __glibcxx_signed(_Tp) ((_Tp)(-1) < 0) #define __glibcxx_digits(_Tp) \ (sizeof(_Tp) * __CHAR_BIT__ - __glibcxx_signed(_Tp)) #define __glibcxx_min(_Tp) \ (__glibcxx_signed(_Tp) ? (_Tp)1 << __glibcxx_digits(_Tp) : (_Tp)0) #define __glibcxx_max(_Tp) \ (__glibcxx_signed(_Tp) ? \ (((((_Tp)1 << (__glibcxx_digits(_Tp) - 1)) - 1) << 1) + 1) : ~(_Tp)0) template struct __numeric_traits_integer { // Only integers for initialization of member constant. static const _Value __min = __glibcxx_min(_Value); static const _Value __max = __glibcxx_max(_Value); // NB: these two also available in std::numeric_limits as compile // time constants, but is big and we avoid including it. static const bool __is_signed = __glibcxx_signed(_Value); static const int __digits = __glibcxx_digits(_Value); }; template const _Value __numeric_traits_integer<_Value>::__min; template const _Value __numeric_traits_integer<_Value>::__max; template const bool __numeric_traits_integer<_Value>::__is_signed; template const int __numeric_traits_integer<_Value>::__digits; #undef __glibcxx_signed #undef __glibcxx_digits #undef __glibcxx_min #undef __glibcxx_max #define __glibcxx_floating(_Tp, _Fval, _Dval, _LDval) \ (std::__are_same<_Tp, float>::__value ? _Fval \ : std::__are_same<_Tp, double>::__value ? _Dval : _LDval) #define __glibcxx_max_digits10(_Tp) \ (2 + __glibcxx_floating(_Tp, __FLT_MANT_DIG__, __DBL_MANT_DIG__, \ __LDBL_MANT_DIG__) * 643L / 2136) #define __glibcxx_digits10(_Tp) \ __glibcxx_floating(_Tp, __FLT_DIG__, __DBL_DIG__, __LDBL_DIG__) #define __glibcxx_max_exponent10(_Tp) \ __glibcxx_floating(_Tp, __FLT_MAX_10_EXP__, __DBL_MAX_10_EXP__, \ __LDBL_MAX_10_EXP__) template struct __numeric_traits_floating { // Only floating point types. See N1822. static const int __max_digits10 = __glibcxx_max_digits10(_Value); // See above comment... static const bool __is_signed = true; static const int __digits10 = __glibcxx_digits10(_Value); static const int __max_exponent10 = __glibcxx_max_exponent10(_Value); }; template const int __numeric_traits_floating<_Value>::__max_digits10; template const bool __numeric_traits_floating<_Value>::__is_signed; template const int __numeric_traits_floating<_Value>::__digits10; template const int __numeric_traits_floating<_Value>::__max_exponent10; template struct __numeric_traits : public __conditional_type::__value, __numeric_traits_integer<_Value>, __numeric_traits_floating<_Value> >::__type { }; _GLIBCXX_END_NAMESPACE_VERSION } // namespace #undef __glibcxx_floating #undef __glibcxx_max_digits10 #undef __glibcxx_digits10 #undef __glibcxx_max_exponent10 #endif c++/8/ext/mt_allocator.h000064400000055723152640040230010724 0ustar00// MT-optimized allocator -*- C++ -*- // Copyright (C) 2003-2018 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the // terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This 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 General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // . /** @file ext/mt_allocator.h * This file is a GNU extension to the Standard C++ Library. */ #ifndef _MT_ALLOCATOR_H #define _MT_ALLOCATOR_H 1 #include #include #include #include #include #if __cplusplus >= 201103L #include #endif namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION using std::size_t; using std::ptrdiff_t; typedef void (*__destroy_handler)(void*); /// Base class for pool object. struct __pool_base { // Using short int as type for the binmap implies we are never // caching blocks larger than 32768 with this allocator. typedef unsigned short int _Binmap_type; // Variables used to configure the behavior of the allocator, // assigned and explained in detail below. struct _Tune { // Compile time constants for the default _Tune values. enum { _S_align = 8 }; enum { _S_max_bytes = 128 }; enum { _S_min_bin = 8 }; enum { _S_chunk_size = 4096 - 4 * sizeof(void*) }; enum { _S_max_threads = 4096 }; enum { _S_freelist_headroom = 10 }; // Alignment needed. // NB: In any case must be >= sizeof(_Block_record), that // is 4 on 32 bit machines and 8 on 64 bit machines. size_t _M_align; // Allocation requests (after round-up to power of 2) below // this value will be handled by the allocator. A raw new/ // call will be used for requests larger than this value. // NB: Must be much smaller than _M_chunk_size and in any // case <= 32768. size_t _M_max_bytes; // Size in bytes of the smallest bin. // NB: Must be a power of 2 and >= _M_align (and of course // much smaller than _M_max_bytes). size_t _M_min_bin; // In order to avoid fragmenting and minimize the number of // new() calls we always request new memory using this // value. Based on previous discussions on the libstdc++ // mailing list we have chosen the value below. // See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html // NB: At least one order of magnitude > _M_max_bytes. size_t _M_chunk_size; // The maximum number of supported threads. For // single-threaded operation, use one. Maximum values will // vary depending on details of the underlying system. (For // instance, Linux 2.4.18 reports 4070 in // /proc/sys/kernel/threads-max, while Linux 2.6.6 reports // 65534) size_t _M_max_threads; // Each time a deallocation occurs in a threaded application // we make sure that there are no more than // _M_freelist_headroom % of used memory on the freelist. If // the number of additional records is more than // _M_freelist_headroom % of the freelist, we move these // records back to the global pool. size_t _M_freelist_headroom; // Set to true forces all allocations to use new(). bool _M_force_new; explicit _Tune() : _M_align(_S_align), _M_max_bytes(_S_max_bytes), _M_min_bin(_S_min_bin), _M_chunk_size(_S_chunk_size), _M_max_threads(_S_max_threads), _M_freelist_headroom(_S_freelist_headroom), _M_force_new(std::getenv("GLIBCXX_FORCE_NEW") ? true : false) { } explicit _Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk, size_t __maxthreads, size_t __headroom, bool __force) : _M_align(__align), _M_max_bytes(__maxb), _M_min_bin(__minbin), _M_chunk_size(__chunk), _M_max_threads(__maxthreads), _M_freelist_headroom(__headroom), _M_force_new(__force) { } }; struct _Block_address { void* _M_initial; _Block_address* _M_next; }; const _Tune& _M_get_options() const { return _M_options; } void _M_set_options(_Tune __t) { if (!_M_init) _M_options = __t; } bool _M_check_threshold(size_t __bytes) { return __bytes > _M_options._M_max_bytes || _M_options._M_force_new; } size_t _M_get_binmap(size_t __bytes) { return _M_binmap[__bytes]; } size_t _M_get_align() { return _M_options._M_align; } explicit __pool_base() : _M_options(_Tune()), _M_binmap(0), _M_init(false) { } explicit __pool_base(const _Tune& __options) : _M_options(__options), _M_binmap(0), _M_init(false) { } private: explicit __pool_base(const __pool_base&); __pool_base& operator=(const __pool_base&); protected: // Configuration options. _Tune _M_options; _Binmap_type* _M_binmap; // Configuration of the pool object via _M_options can happen // after construction but before initialization. After // initialization is complete, this variable is set to true. bool _M_init; }; /** * @brief Data describing the underlying memory pool, parameterized on * threading support. */ template class __pool; /// Specialization for single thread. template<> class __pool : public __pool_base { public: union _Block_record { // Points to the block_record of the next free block. _Block_record* _M_next; }; struct _Bin_record { // An "array" of pointers to the first free block. _Block_record** _M_first; // A list of the initial addresses of all allocated blocks. _Block_address* _M_address; }; void _M_initialize_once() { if (__builtin_expect(_M_init == false, false)) _M_initialize(); } void _M_destroy() throw(); char* _M_reserve_block(size_t __bytes, const size_t __thread_id); void _M_reclaim_block(char* __p, size_t __bytes) throw (); size_t _M_get_thread_id() { return 0; } const _Bin_record& _M_get_bin(size_t __which) { return _M_bin[__which]; } void _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t) { } explicit __pool() : _M_bin(0), _M_bin_size(1) { } explicit __pool(const __pool_base::_Tune& __tune) : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { } private: // An "array" of bin_records each of which represents a specific // power of 2 size. Memory to this "array" is allocated in // _M_initialize(). _Bin_record* _M_bin; // Actual value calculated in _M_initialize(). size_t _M_bin_size; void _M_initialize(); }; #ifdef __GTHREADS /// Specialization for thread enabled, via gthreads.h. template<> class __pool : public __pool_base { public: // Each requesting thread is assigned an id ranging from 1 to // _S_max_threads. Thread id 0 is used as a global memory pool. // In order to get constant performance on the thread assignment // routine, we keep a list of free ids. When a thread first // requests memory we remove the first record in this list and // stores the address in a __gthread_key. When initializing the // __gthread_key we specify a destructor. When this destructor // (i.e. the thread dies) is called, we return the thread id to // the front of this list. struct _Thread_record { // Points to next free thread id record. NULL if last record in list. _Thread_record* _M_next; // Thread id ranging from 1 to _S_max_threads. size_t _M_id; }; union _Block_record { // Points to the block_record of the next free block. _Block_record* _M_next; // The thread id of the thread which has requested this block. size_t _M_thread_id; }; struct _Bin_record { // An "array" of pointers to the first free block for each // thread id. Memory to this "array" is allocated in // _S_initialize() for _S_max_threads + global pool 0. _Block_record** _M_first; // A list of the initial addresses of all allocated blocks. _Block_address* _M_address; // An "array" of counters used to keep track of the amount of // blocks that are on the freelist/used for each thread id. // - Note that the second part of the allocated _M_used "array" // actually hosts (atomic) counters of reclaimed blocks: in // _M_reserve_block and in _M_reclaim_block those numbers are // subtracted from the first ones to obtain the actual size // of the "working set" of the given thread. // - Memory to these "arrays" is allocated in _S_initialize() // for _S_max_threads + global pool 0. size_t* _M_free; size_t* _M_used; // Each bin has its own mutex which is used to ensure data // integrity while changing "ownership" on a block. The mutex // is initialized in _S_initialize(). __gthread_mutex_t* _M_mutex; }; // XXX GLIBCXX_ABI Deprecated void _M_initialize(__destroy_handler); void _M_initialize_once() { if (__builtin_expect(_M_init == false, false)) _M_initialize(); } void _M_destroy() throw(); char* _M_reserve_block(size_t __bytes, const size_t __thread_id); void _M_reclaim_block(char* __p, size_t __bytes) throw (); const _Bin_record& _M_get_bin(size_t __which) { return _M_bin[__which]; } void _M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block, size_t __thread_id) { if (__gthread_active_p()) { __block->_M_thread_id = __thread_id; --__bin._M_free[__thread_id]; ++__bin._M_used[__thread_id]; } } // XXX GLIBCXX_ABI Deprecated void _M_destroy_thread_key(void*) throw (); size_t _M_get_thread_id(); explicit __pool() : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) { } explicit __pool(const __pool_base::_Tune& __tune) : __pool_base(__tune), _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) { } private: // An "array" of bin_records each of which represents a specific // power of 2 size. Memory to this "array" is allocated in // _M_initialize(). _Bin_record* _M_bin; // Actual value calculated in _M_initialize(). size_t _M_bin_size; _Thread_record* _M_thread_freelist; void* _M_thread_freelist_initial; void _M_initialize(); }; #endif template