diff --git a/AGENTS.md b/AGENTS.md index ac1e2fe1c6..ea6aa1fe06 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -457,6 +457,49 @@ See `local/docs/BUILD-SYSTEM-HARDENING-PLAN.md` for the full plan. - **DO NOT** skip warnings — investigate, diagnose, and fix the root cause; suppressing or ignoring warnings is not acceptable when a fix is feasible - **DO NOT** remove patches from `recipe.toml` to fix build failures — rebase the patch instead (see `local/docs/PATCH-GOVERNANCE.md`) - **DO NOT** remove BINS entries to fix build failures — fix the source or use EXISTING_BINS filtering +- **DO NOT** use the VESA display driver (`vesad`) as the primary display surface after GPU detection. vesad is only for early-boot framebuffer handoff — after redox-drm loads, the display path is `/scheme/drm/card0`. See **NO VESA POLICY** below. + +## NO VESA POLICY + +Red Bear OS does not use the VESA display driver as the primary display surface. All display +output goes through the DRM/KMS path via real GPU drivers: + +| Environment | GPU Driver | 3D Support | +|---|---|---| +| QEMU | virtio-gpu (via redox-drm) | ✅ virgl | +| Intel hardware | Intel i915-like (via redox-drm) | ✅ Mesa i965/iris | +| AMD hardware | amdgpu (via redox-drm + linux-kpi) | ✅ Mesa radeonsi | +| Future | nouveau reimplementation (Rust, via redox-drm) | ✅ Mesa nouveau | + +**vesad is allowed ONLY as an early-boot framebuffer handoff.** The bootloader sets up a linear +framebuffer before the kernel starts. vesad takes over this framebuffer so the initfs has console +output (fbcond, fbbootlogd) before real GPU drivers are available. Once redox-drm initializes and +registers `scheme:drm/card0`, vesad must hand off and NOT register `scheme:display.vesa` as the +primary display surface. + +The display path for redbear-full: + +``` +Bootloader linear framebuffer + → vesad (initfs, service 20): temporary FB handoff for text console + → redox-drm (initfs, service 30): detects GPU hardware, takes over via DRM/KMS + → redox-drm (rootfs, service 14): full DRM driver with 3D (Mesa) + → KWin compositor: DRM/KMS master, composites desktop via /scheme/drm/card0 +``` + +For redbear-mini: vesad handles the bootloader framebuffer for the text-only console. No GPU +driver loads — mini is text-only by design. + +**After GPU detection, any code that opens `/scheme/display.vesa/` is incorrect.** The correct +display path is `/scheme/drm/card0` via the DRM scheme. + +Rationale: VESA is a legacy BIOS-era standard with no hardware acceleration, no mode setting +beyond what the bootloader provides, no 3D, and no future. Red Bear OS targets real GPU +hardware with full DRM/KMS and Mesa support. vesad serves only as a bridge between bootloader +FB and the real GPU driver — it is never the final display path. + +This policy also covers future GPU driver work: any new GPU support (nouveau Rust reimplementation, +ARM Mali, etc.) must go through the redox-drm + DRM/KMS path, never through VESA fallback. ## ZERO TOLERANCE FOR STUBS diff --git a/config/redbear-device-services.toml b/config/redbear-device-services.toml index 3b91fa8873..75402c1c92 100644 --- a/config/redbear-device-services.toml +++ b/config/redbear-device-services.toml @@ -444,7 +444,7 @@ requires_weak = ["04_drivers.target"] [service] cmd = "/usr/bin/coretempd" -type = { scheme = "coretemp" } +type = "oneshot_async" """ [[files]] diff --git a/config/redbear-full.toml b/config/redbear-full.toml index 77035f90c8..3b3e97be0f 100644 --- a/config/redbear-full.toml +++ b/config/redbear-full.toml @@ -6,6 +6,13 @@ # # Extends redbear-mini with the full desktop/graphics stack: # Wayland, Qt6, KF6, KWin, Mesa, DRM drivers, firmware, greeter. +# +# GPU/display policy: DRM/KMS ONLY. No VESA. Real GPU drivers: +# QEMU → virtio-gpu via redox-drm (virgl 3D) +# Intel → i915-like via redox-drm (Mesa i965/iris) +# AMD → amdgpu via redox-drm + linux-kpi (Mesa radeonsi) +# Display path: bootloader FB → redox-drm → DRM/KMS → KWin compositor +# Consult local/reference/linux-7.0/ for driver behavior reference. include = ["redbear-mini.toml"] @@ -57,7 +64,7 @@ fontconfig = {} libwayland = {} wayland-protocols = {} plasma-wayland-protocols = {} -redbear-compositor = "ignore" # replaced by kwin +redbear-compositor = {} # Keyboard/input libxkbcommon = {} diff --git a/local/docs/DRIVER-DISCOVERY-AND-MAPPING-PLAN.md b/local/docs/DRIVER-DISCOVERY-AND-MAPPING-PLAN.md new file mode 100644 index 0000000000..455384d394 --- /dev/null +++ b/local/docs/DRIVER-DISCOVERY-AND-MAPPING-PLAN.md @@ -0,0 +1,363 @@ +# Driver Discovery and Dynamic Hardware Mapping Plan + +**Status**: Draft — implementation pending +**Date**: 2026-05-27 +**Supersedes**: Ad-hoc pcid-spawner + hardcoded lived disk paths +**Author**: Red Bear OS team + +--- + +## 1. Problem Statement + +Red Bear OS has two critical gaps in hardware discovery: + +1. **lived's disk fallback is broken**: The live ISO boot daemon (`lived`) tries hardcoded paths `/scheme/disk/0` and `/scheme/usbscsi/0` to find the physical boot disk. But no disk driver registers those exact scheme names — they register `disk.pci-00-1F-2_ahci`, `disk.usb-xhci+1-scsi`, etc. The fallback **never works**. + +2. **No dynamic hardware mapping**: The system does not distinguish between "hardware present" and "driver needed." On bare metal with no virtio devices, the system should not try to load `virtio-blkd`. On QEMU with no real AHCI controller, the system should not try to load `ahcid`. Today, the driver-manager loads whatever matches its static config files regardless of whether the hardware exists. + +Linux solves both problems with a two-stage model: +- **Stage 1 (initramfs)**: Enumerate PCI bus, load ONLY the storage driver matching the boot controller, mount rootfs. +- **Stage 2 (rootfs)**: Full enumeration, udev + modprobe dynamically load all remaining drivers based on actual hardware. + +--- + +## 2. Current Architecture + +### 2.1 Boot Sequence (Initfs Phase) + +``` +Bootstrap (PID 1) → init → services start in dependency order: + + 00_runtime.target randd, nulld, zerod, rtcd, logd + 10_inputd.service VT input multiplexer + 10_lived.service Live disk daemon (RAM preload + disk fallback) + 20_graphics.target vesad (FB handoff), fbcond, fbbootlogd + 41_acpid.service ACPI interpreter → scheme:acpi + 40_hwd.service Hardware manager → spawns pcid internally + pcid → enumerates PCI bus → registers scheme:pci + 00_driver-manager-initfs.service (if P26 applied) + Loads /scheme/initfs/lib/drivers.d/00-storage.toml + Only: ahcid, ided, nvmed, virtio-blkd + 40_drivers.target All initfs drivers + 50_rootfs.service Mount rootfs (hard dep on drivers.target) + 90_initfs.target Trigger switchroot +``` + +### 2.2 Driver Registration Contract + +All disk drivers using `driver_block::DiskScheme` register schemes starting with `"disk"`: + +| Driver | Scheme Name Pattern | Match Criteria | +|--------|---------------------|----------------| +| ided | `disk.pci-XX-XX-X_ide` | PCI class 0x01, subclass 0x01 | +| ahcid | `disk.pci-XX-XX-X_ahci` | PCI class 0x01, subclass 0x06 | +| nvmed | `disk.pci-XX-XX-X-nvme` | PCI class 0x01, subclass 0x08 | +| virtio-blkd | `disk.pci-XX-XX-X_virtio_blk` | PCI vendor 0x1AF4, device 0x1001 | +| usbscsid | `disk.usb-xhci+PORT-scsi` | USB SCSI transport | +| lived | `disk.live` | RAM-backed (our daemon) | + +The `DiskScheme::new()` assertion (`assert!(scheme_name.starts_with("disk"))`) is the **contract** that enables dynamic discovery: any consumer can find all disk schemes by listing `/scheme/` and filtering for the `"disk"` prefix. + +### 2.3 The Two Driver-Loading Paths + +| Path | Mechanism | Config Source | Drivers | +|------|-----------|---------------|---------| +| **Initfs** | `driver-manager --initfs` | `/scheme/initfs/lib/drivers.d/00-storage.toml` | Storage only (4 drivers) | +| **Rootfs** | `driver-manager --hotplug` | `/lib/drivers.d/*.toml` | All categories (40+ drivers) | + +### 2.4 How Linux Does It (Reference) + +Linux uses a two-tier ordering: + +**Tier 1 — Initcall levels** (include/linux/init.h): +``` +Level 0: pure_initcall (architecture setup) +Level 2: postcore_initcall (PCI subsystem registers here) +Level 4: subsys_initcall (SCSI, networking subsystems) +Level 6: device_initcall (module_init → all built-in drivers) +Level 7: late_initcall (late-stage platform drivers) +``` + +**Tier 2 — Link order** within device_initcall (drivers/Makefile): +``` +Line 49: obj-y += virtio/ # VirtIO before block +Line 76: obj-y += block/ # Block devices (storage) +Line 84: obj-y += nvme/ # NVMe +Line 85: obj-y += ata/ # ATA/AHCI +Line 92: obj-y += net/ # Network +Line 68: obj-y += gpu/ # GPU comes AFTER storage +``` + +**The critical principle**: Storage must load before GPU not because of PCI ordering, but because GPU drivers need firmware blobs from `/lib/firmware/` — which requires a mounted filesystem. Storage drivers are needed to mount that filesystem. + +**Dynamic loading** (after rootfs mount): `MODULE_DEVICE_TABLE` entries in every driver generate `modules.alias` patterns. udev receives kernel uevents with `MODALIAS=pci:v00001AF4d00001001...`, calls `modprobe`, which looks up the alias and loads the matching `.ko` module. + +--- + +## 3. Design: Two-Stage Dynamic Hardware Discovery + +### 3.1 Stage 1 — Initfs Boot (Storage-Only) + +**Goal**: Load exactly the storage driver(s) needed to mount the root filesystem. No more, no less. + +**Mechanism**: driver-manager `--initfs` already exists and does PCI class/vendor matching. The missing piece is that the P26 patch (which creates `00_driver-manager-initfs.service` and `initfs-storage.toml`) is wired in `recipe.toml` but needs to be applied. + +**Initfs driver config** (`initfs-storage.toml`): + +```toml +# Only storage drivers — needed to mount rootfs +# GPU/display deliberately excluded (handled by rootfs DRM/KMS stack) + +[[driver]] +name = "nvmed" +description = "NVMe storage driver" +priority = 100 +command = ["/scheme/initfs/lib/drivers/nvmed"] + +[[driver.match]] +bus = "pci" +class = 1 +subclass = 8 + +[[driver]] +name = "ahcid" +description = "AHCI SATA driver" +priority = 100 +command = ["/scheme/initfs/lib/drivers/ahcid"] + +[[driver.match]] +bus = "pci" +class = 1 +subclass = 6 + +[[driver]] +name = "ided" +description = "PATA IDE driver" +priority = 100 +command = ["/scheme/initfs/lib/drivers/ided"] + +[[driver.match]] +bus = "pci" +class = 1 +subclass = 1 + +[[driver]] +name = "virtio-blkd" +description = "VirtIO block device driver" +priority = 100 +command = ["/scheme/initfs/lib/drivers/virtio-blkd"] + +[[driver.match]] +bus = "pci" +vendor = 0x1AF4 +device = 0x1001 +``` + +**How this is already dynamic**: The driver-manager only spawns a driver when the PCI bus actually reports a matching device. If QEMU has no AHCI controller, `ahcid` is never spawned. If bare metal has no VirtIO devices, `virtio-blkd` is never spawned. The TOML match table is a **candidate list**, not a **must-load list**. + +**What's needed**: Ensure P26 is applied, ensure `virtio-blkd` is in the BINS list, and ensure the initfs binary staging includes all 4 storage drivers. + +### 3.2 Stage 2 — Rootfs (Full Hardware Discovery) + +**Goal**: After rootfs is mounted, dynamically discover and load ALL remaining drivers based on actual hardware. + +**Mechanism**: `driver-manager --hotplug` already reads `/lib/drivers.d/*.toml` (8 config files, 40+ drivers), enumerates PCI + ACPI buses, and spawns matching drivers. It also runs a hotplug loop for device add/remove. + +**The existing driver configs are already data-driven and dynamic**: + +| Config File | Category | Priority | Matching | +|-------------|----------|----------|----------| +| `00-storage.toml` | Storage | 100 | PCI class-based | +| `10-network.toml` | Network | 50 | PCI vendor + class | +| `20-usb.toml` | USB | 80 | PCI class + prog_if | +| `30-graphics.toml` | GPU/Display | 60 | PCI class 0x03 | +| `40-input.toml` | Input | 40 | Sentinel (vendor=0xFFFF) | +| `50-audio.toml` | Audio | 40 | PCI vendor + class | +| `60-gpio-i2c.toml` | GPIO/I2C | 30 | ACPI bus matching | +| `70-usb-class.toml` | USB class | 20 | Sentinel (vendor=0xFFFF) | + +**Key property**: Priority ordering ensures storage (100) > USB (80) > GPU (60) > network (50) > audio (40). This mirrors Linux's link-order principle. + +### 3.3 lived Disk Fallback Fix + +**Current bug**: `lived` tries `/scheme/disk/0` — but real schemes are named `disk.pci-00-1F-2_ahci`, never just `disk`. + +**Fix**: Replace hardcoded paths with RedoxFS-style dynamic scheme discovery (same pattern as `filesystem_by_uuid` in `redoxfs/src/bin/mount.rs`): + +```rust +fn try_open_disk(&self) -> Result { + for attempt in 0..DISK_OPEN_MAX_RETRIES { + // List /scheme/ to find all registered disk schemes + if let Ok(entries) = std::fs::read_dir("/scheme") { + for entry in entries.flatten() { + let name = entry.file_name(); + let name_str = name.to_string_lossy(); + + // All disk schemes start with "disk." (driver-block contract) + // Skip our own "disk.live" scheme + if name_str.starts_with("disk.") && name_str != "disk.live" { + // Try opening disk 0 on this scheme + let path = format!("/scheme/{}/0", name_str); + if let Ok(file) = File::open(&path) { + eprintln!("lived: opened physical disk at {} (attempt {})", + path, attempt + 1); + return Ok(file); + } + } + } + } + + if attempt < DISK_OPEN_MAX_RETRIES - 1 { + std::thread::sleep(std::time::Duration::from_millis( + DISK_OPEN_RETRY_INTERVAL_MS + )); + } + } + + Err(format!("no disk scheme found after {} retries", DISK_OPEN_MAX_RETRIES)) +} +``` + +**This is the exact pattern RedoxFS uses** in `filesystem_by_uuid()`. It: +1. Lists `/scheme/` (all registered schemes) +2. Filters to names starting with `"disk."` (the `driver-block` contract) +3. Skips `disk.live` (our own RAM-backed scheme) +4. Tries opening disk 0 on each discovered scheme + +**Boot timing**: lived starts at service 10, before disk drivers. The retry loop (60 × 500ms = 30s) gives driver-manager and storage drivers time to load and register their schemes. As soon as ANY storage driver registers `disk.*`, lived finds it. + +--- + +## 4. What Needs to Change + +### 4.1 Patches Required + +| Component | Patch | What It Does | +|-----------|-------|--------------| +| **base** | P60 (new) | Add `virtio-blkd` to BINS + staged files; update lived's `try_open_disk()` with dynamic scheme discovery | +| **kernel** | P26 (existing) | DebugDisplay scrolling fix (already done) | +| **base** | P26-driver-manager-initfs-conversion.patch (existing, wired but needs application verification) | Replaces pcid-spawner with driver-manager in initfs | + +### 4.2 Changes to `recipes/core/base/recipe.toml` + +1. **Add `virtio-blkd` to BINS** (already done in working tree) +2. **Add `virtio-blkd` to staged files list** (already done in working tree) +3. **No changes to driver configs** — `initfs-storage.toml` already lists all 4 storage drivers + +### 4.3 Changes to `recipes/core/base/source/drivers/storage/lived/src/main.rs` + +Replace the hardcoded `candidates` array in `try_open_disk()` with `/scheme/` directory enumeration that discovers disk schemes dynamically. + +### 4.4 No Changes Needed + +- **driver-manager** — already does dynamic PCI matching +- **initfs-storage.toml** — already has the right 4 storage drivers +- **Driver configs** (`/lib/drivers.d/*.toml`) — already data-driven with vendor/class matching +- **pcid** — already enumerates PCI bus correctly +- **Boot service order** — already correct (lived at 10, driver-manager-initfs at 00, rootfs at 50) + +--- + +## 5. Verification Plan + +### 5.1 QEMU with IDE (default) + +```bash +timeout 60 qemu-system-x86_64 \ + -drive file=build/x86_64/redbear-full.iso,format=raw \ + -m 4G -smp 4 -serial stdio -no-reboot +``` + +Expected: lived finds `disk.pci-00-01-1_ide` scheme from `ided`, mounts rootfs. + +### 5.2 QEMU with virtio-blk + +```bash +timeout 60 qemu-system-x86_64 \ + -device virtio-blk-pci,drive=drive0 \ + -drive id=drive0,file=build/x86_64/redbear-full.iso,format=raw,if=none \ + -m 4G -smp 4 -serial stdio -no-reboot +``` + +Expected: lived finds `disk.pci-00-XX-X_virtio_blk` scheme from `virtio-blkd`, mounts rootfs. + +### 5.3 Bare Metal USB Boot + +Expected: lived finds `disk.usb-xhci+PORT-scsi` scheme from `usbscsid`, mounts rootfs. + +### 5.4 No Unnecessary Drivers + +On QEMU with only virtio-blk (no AHCI), `ahcid` should NOT be spawned. Verify via boot log: +``` +driver-manager: no driver found for pci 0000:00:01.1 # IDE controller — no match +driver-manager: bound: 0000:00:04.0 -> virtio-blkd # VirtIO block — matched +``` + +--- + +## 6. PCI Class Code Reference + +From Linux `include/linux/pci_ids.h` and our driver configs: + +| Class | Subclass | Prog IF | Device Type | Red Bear Driver | +|-------|----------|---------|-------------|-----------------| +| 0x01 | 0x01 | — | IDE/PATA | `ided` | +| 0x01 | 0x06 | 0x01 | AHCI SATA | `ahcid` | +| 0x01 | 0x08 | 0x02 | NVMe | `nvmed` | +| 0x01 | 0x00 | — | VirtIO Block (vendor 0x1AF4, device 0x1001) | `virtio-blkd` | +| 0x02 | — | — | Ethernet | `e1000d`, `rtl8168d`, etc. | +| 0x03 | — | — | Display/GPU | `redox-drm` | +| 0x04 | 0x03 | — | Audio (HDA) | `ihdad` | +| 0x0C | 0x03 | 0x30 | xHCI USB | `xhcid` | +| 0x0C | 0x03 | 0x00 | UHCI USB | `uhcid` | +| 0x0C | 0x03 | 0x10 | OHCI USB | `ohcid` | +| 0x0C | 0x03 | 0x20 | EHCI USB | `ehcid` | + +--- + +## 7. Boot Timeline (Target State) + +``` +T+0ms Bootstrap starts, creates initfs/procmgr/namespace schemes +T+50ms init starts, launches 00_randd → 00_logd → 00_runtime.target +T+200ms lived starts (service 10), loads 128 MiB preload +T+300ms vesad starts (FB handoff for text console) +T+400ms acpid starts → ACPI interpreter → scheme:acpi +T+500ms hwd starts → spawns pcid → PCI bus scan → scheme:pci + driver-manager --initfs starts: + Loads 00-storage.toml (4 storage drivers) + Enumerates PCI bus via /scheme/pci/ + QEMU: finds 8086:7010 (IDE) → spawns ided + finds 1234:1111 (virtio-gpu) → no storage match, skipped + finds 1AF4:1050 (virtio-net) → no storage match, skipped +T+1500ms ided registers disk.pci-00-01-1_ide + lived discovers disk.pci-00-01-1_ide via /scheme/ enumeration + lived disk fallback succeeds +T+2000ms redoxfs mounts rootfs from lived +T+2500ms switchroot → rootfs init starts +T+3000ms driver-manager --hotplug starts (rootfs): + Loads all /lib/drivers.d/*.toml configs + Detects ided already bound → skips + Finds 1234:1111 (display class 0x03) → spawns redox-drm + Finds 8086:100E (network class 0x02) → spawns e1000d + Finds 1AF4:1050 (virtio-net) → spawns virtio-netd +T+5000ms All drivers bound, system fully operational +``` + +--- + +## 8. Principles + +1. **Data-driven, not hardcoded**: Driver matching via TOML configs with vendor/device/class fields. No binary name hardcoding, no path guessing. + +2. **Enumerate first, match second**: PCI bus scan produces ALL devices. Driver matching filters to supported ones. Unknown hardware is logged but doesn't block boot. + +3. **Priority ordering**: Storage (100) before USB (80) before GPU (60) before network (50) before audio (40). Mirrors Linux's link-order principle. + +4. **Stage 1 = minimum viable set**: Initfs loads ONLY storage drivers. Everything else waits for rootfs. + +5. **Dynamic scheme discovery**: lived discovers disk schemes by reading `/scheme/` and filtering for the `"disk."` prefix — the same contract that `driver-block` enforces. + +6. **No unnecessary drivers**: If hardware doesn't exist, the driver is never spawned. `driver-manager` only calls `probe()` for devices that actually exist on the PCI/ACPI bus. + +7. **Deferred retry for timing**: Drivers that start before their dependencies are ready get retried (3 times in initfs, 5 times in hotplug). After max retries, the device is permanently skipped with a logged reason. diff --git a/local/docs/LIVE-ISO-MOUNT-PLAN.md b/local/docs/LIVE-ISO-MOUNT-PLAN.md new file mode 100644 index 0000000000..1e292a76cd --- /dev/null +++ b/local/docs/LIVE-ISO-MOUNT-PLAN.md @@ -0,0 +1,483 @@ +# Live ISO Mount — Architecture, Failure Analysis, and Fix Plan + +**Date:** 2026-05-27 +**Status:** Draft — fixes not yet implemented +**Scope:** Bootloader live preload, lived daemon, RedoxFS mount chain + +--- + +## 1. Current Architecture + +### 1.1 Boot Flow (Live ISO) + +``` +UEFI firmware + → Bootloader (recipes/core/bootloader/source/src/main.rs) + 1. Find RedoxFS partition on disk + 2. Read filesystem header → get total filesystem size (e.g., 4093 MiB) + 3. Live preload: read first N MiB of filesystem into RAM + - Cap: max_preload = 1024 MiB (line 559) + - Set env: DISK_LIVE_ADDR=, DISK_LIVE_SIZE= + - Set env: REDOXFS_BLOCK=0 (start of partition) + 4. Load kernel from RedoxFS into memory + 5. Load initfs from RedoxFS into memory + 6. Set up paging, pass env to kernel + 7. Jump to kernel entry point + +Kernel + → bootstrap (initfs) + → init daemon + → lived daemon (10_lived.service) + - Reads DISK_LIVE_ADDR + DISK_LIVE_SIZE from env + - Maps preloaded RAM as LiveDisk via /scheme/memory/physical + - Registers scheme:disk.live + - LiveDisk.size() = preloaded size (1024 MiB) + - LiveDisk.block_size() = PAGE_SIZE (4096) [P6 patch changes to 512] + + → redoxfs daemon (50_rootfs.service) + - Opens /scheme/disk.live/0 as DiskFile + - Calls FileSystem::open(disk, password, block=0, cleanup=true) + - Reads header at block 0 (inside preloaded region → works) + - Calls fs.reset_allocator() → walks the allocation tree + - Calls fs.cleanup() → may read blocks across the entire filesystem + - FAILURE: any read beyond preloaded size returns EINVAL +``` + +### 1.2 Component Map + +| Component | Source | Role | +|-----------|--------|------| +| **Bootloader** | `recipes/core/bootloader/source/src/main.rs` | Preloads filesystem into RAM, passes env vars | +| **lived** | `recipes/core/base/source/drivers/storage/lived/src/main.rs` | Maps preloaded RAM as `scheme:disk.live` | +| **RedoxFS mount** | `recipes/core/redoxfs/source/src/bin/mount.rs` | Opens disk scheme, calls FileSystem::open | +| **RedoxFS lib** | `recipes/core/redoxfs/source/src/filesystem.rs` | Reads header, walks allocator tree | +| **driver-block** | `recipes/core/base/source/drivers/storage/driver-block/src/lib.rs` | DiskWrapper with block_size alignment checks | +| **P6 patch** | `local/patches/base/P6-lived-block-size-512.patch` | Changes block_size from PAGE_SIZE to 512 | + +### 1.3 The Preload Cap + +```rust +// bootloader/src/main.rs:559 +let max_preload: u64 = 1024 * MIBI as u64; // 1 GiB hard cap +let preload_size = if size > max_preload { + max_preload // Cap at 1 GiB +} else { + size // Preload entire filesystem if ≤ 1 GiB +}; +``` + +For redbear-full (4093 MiB filesystem): preloads 1024 MiB, 3069 MiB must come from disk. +For redbear-mini (1533 MiB filesystem): preloads 1024 MiB, 509 MiB must come from disk. + +### 1.4 The lived Disk + +```rust +// lived/src/main.rs - LiveDisk::read (CURRENT, unpatched source) +fn block_size(&self) -> u32 { + PAGE_SIZE as u32 // P6 changes this to 512 +} + +fn size(&self) -> u64 { + self.original.len() as u64 // This is the PRELOADED size, not total filesystem size +} + +async fn read(&mut self, mut block: u64, buffer: &mut [u8]) -> syscall::Result { + let mut offset = (block as usize) * PAGE_SIZE; + if offset + buffer.len() > self.original.len() { + return Err(syscall::Error::new(EINVAL)); // ← THIS IS THE FAILURE POINT + } + // ... read from preloaded buffer +} +``` + +**The fundamental problem:** `lived` only has the preloaded buffer (1024 MiB). It has no +access to the remaining filesystem data on the physical disk. When RedoxFS tries to read +beyond 1024 MiB, lived returns EINVAL. + +--- + +## 2. Failure Analysis + +### 2.1 Why Does the Mini ISO Work? + +The mini ISO (1533 MiB) also has 509 MiB beyond the preload. However: + +1. RedoxFS `FileSystem::open` reads the header at block 0 (within preload) → OK +2. `reset_allocator` walks the free block tree. For a 1533 MiB filesystem with minimal + contents, the allocator metadata is concentrated near the start → likely within 1024 MiB +3. `cleanup` reads extent nodes — for a small filesystem, these are also near the start + +For the full ISO (4093 MiB) with hundreds of packages: +- The allocator tree and extent nodes span the entire 4093 MiB range +- RedoxFS needs to read blocks at offsets > 1024 MiB during `FileSystem::open` +- lived rejects those reads → mount fails + +**The mini ISO works by luck** — its metadata happens to fit within the preload window. +This is not a reliable design. + +### 2.2 The Exact Error Chain + +``` +RedoxFS FileSystem::open + → disk.read_at(block_N, &mut header) + → DiskFile::read_at(buffer, block_N * BLOCK_SIZE) + → syscall::read(scheme:disk.live/0, offset=block_N * 512) + → lived::LiveDisk::read(block_N, buffer) + → offset = block_N * PAGE_SIZE // or 512 with P6 + → if offset + buffer.len() > self.original.len(): + return Err(EINVAL) // ← HERE +``` + +The error propagates: +- lived → EINVAL +- DiskFile → "RedoxFS: IO ERROR: Invalid argument (os error 22)" +- FileSystem::open → Err(EINVAL) +- mount.rs → "not able to mount uuid ..." + +### 2.3 The P6 Block Size Patch + +The P6 patch (`local/patches/base/P6-lived-block-size-512.patch`) fixes a different but +related issue: the original `block_size()` returned `PAGE_SIZE` (4096), but RedoxFS reads +in 512-byte chunks (`BLOCK_SIZE = 4096` but individual reads may be 512). The `DiskWrapper` +in `driver-block` rejects misaligned reads. Changing to 512 fixes alignment but does NOT +fix the size/out-of-bounds problem. + +**Note:** The current source tree (`recipes/core/base/source/drivers/storage/lived/src/main.rs`) +does NOT have the P6 patch applied — it still shows `PAGE_SIZE as u32`. The P6 patch is +applied during `repo fetch base` and only exists durably in `local/patches/base/`. + +--- + +## 3. Fix Strategy + +### 3.1 Design Principle + +> Preload the minimum needed to boot the kernel + initfs. Once the OS is running, mount +> the filesystem from the actual disk device, not from the RAM preload. + +The bootloader already loads kernel + initfs from RedoxFS before switching to live mode. +After that, the running OS has access to the AHCI driver (ahcid) and can mount the +filesystem directly from the physical disk. + +### 3.2 Two-Phase Approach + +**Phase A: Bootloader Changes** (bootloader is UEFI code, runs before the OS) + +1. **Reduce preload to the minimum needed for kernel + initfs discovery** + - The bootloader needs to read the RedoxFS superblock + directory tree to find + `usr/lib/boot/kernel` and `usr/lib/boot/initfs`. This requires reading the header, + the root node, and walking directory entries. + - Instead of preloading a fixed 1024 MiB, preload only what's needed to locate and + read these two files. In practice, this is the first few MiB of the filesystem. + - Fallback: if the filesystem is small enough (≤ 64 MiB?), preload everything. + +2. **Pass the physical disk location to the kernel** + - Set `DISK_PHYS_ADDR` and `DISK_PHYS_SIZE` env vars with the full disk geometry + - Keep `DISK_LIVE_ADDR` / `DISK_LIVE_SIZE` for the minimal preload + - Add `REDOXFS_FULL_SIZE` so the OS knows the true filesystem extent + +**Phase B: lived Daemon Changes** (OS-level, patchable via `local/patches/base/`) + +1. **Accept the full filesystem size as an additional env var** + - Read `REDOXFS_FULL_SIZE` or derive from the RedoxFS header + - Report `LiveDisk::size()` as the FULL filesystem size, not just the preload + +2. **Fall through to the physical disk for reads beyond the preload** + - When `read(block, buffer)` is called with an offset beyond `self.original.len()`: + - Open the underlying block device (e.g., `/scheme/disk/0` after ahcid starts) + - Read the data from the physical disk + - Cache the result in the overlay HashMap + - This makes lived act as a write-through cache: preload in RAM, fallback to disk + +3. **Alternative simpler approach: bypass lived entirely for large images** + - After ahcid starts and registers `/scheme/disk/0`, the init system could mount + RedoxFS directly from `/scheme/disk/0` instead of `/scheme/disk.live/0` + - The preload would only be used by the bootloader to load kernel + initfs + - Once the OS boots, lived is unnecessary — mount from the real disk + +--- + +## 4. Concrete Fix Plan + +### 4.1 Fix 1: Reduce Bootloader Preload (bootloader patch) + +**File:** `recipes/core/bootloader/source/src/main.rs` + +**Current:** +```rust +let max_preload: u64 = 1024 * MIBI as u64; +``` + +**Proposed change:** +```rust +// Only preload what the bootloader actually needs: +// - RedoxFS header + allocator (first ~1 MiB) +// - Root directory tree (typically first 32-64 MiB) +// - kernel and initfs files (loaded separately after preload) +// 64 MiB is generous for the metadata region of any reasonable filesystem. +// The kernel and initfs are loaded separately via fs.disk.read_at() directly +// from the physical disk, so they don't need to be in the preload. +let max_preload: u64 = 64 * MIBI as u64; +``` + +Wait — this doesn't work. The bootloader reads kernel and initfs from the RedoxFS +filesystem using `load_to_memory(os, &mut fs, "usr/lib/boot/kernel", ...)`. After the +preload, the bootloader has already switched the disk to the live buffer. So the kernel +and initfs must be within the preload, OR the bootloader must load them before switching +to live mode. + +**Looking at the actual bootloader flow:** +``` +1. Open RedoxFS from physical disk → fs +2. Preload first N MiB into RAM buffer +3. Set LIVE_OPT = Some((fs.block, buffer)) +4. Load kernel from fs (still using physical disk? or from buffer?) +5. Load initfs from fs +6. Pass LIVE_OPT to kernel env +``` + +The live buffer is set in `LIVE_OPT` at line 625, but the kernel and initfs are loaded +at lines 642-663, AFTER the live preload. The `load_to_memory` function uses `fs` which +still uses the original disk handle. So the kernel and initfs are read from the physical +disk, not from the live buffer. + +**This means the preload doesn't need to include kernel or initfs at all.** The preload +exists solely so that `lived` can serve the filesystem to the running OS via `scheme:disk.live`. + +**Revised Fix 1:** Reduce max_preload to a small value (e.g., 4-64 MiB) that covers just +the RedoxFS metadata needed for initial mount, then rely on the disk fallback for the rest. + +BUT: this only works if `lived` can fall through to the physical disk for out-of-bounds +reads. Without the fallback, reducing preload makes the problem worse. + +### 4.2 Fix 2: lived Disk Fallback (base patch) + +**File:** `recipes/core/base/source/drivers/storage/lived/src/main.rs` + +This is the core fix. Make `lived` aware of the full filesystem and able to read from +the physical disk when the preload doesn't cover the requested region. + +**Design:** + +```rust +struct LiveDisk { + // Preloaded RAM buffer (may be smaller than total filesystem) + preload: &'static [u8], + // Full filesystem size (from RedoxFS header or env var) + total_size: u64, + // Physical disk offset where the filesystem starts + disk_block: u64, + // Handle to the physical disk (opened after ahcid starts) + disk_handle: Option, + // Write overlay (same as before) + overlay: HashMap>, +} + +impl Disk for LiveDisk { + fn block_size(&self) -> u32 { 512 } + + fn size(&self) -> u64 { self.total_size } + + async fn read(&mut self, block: u64, buffer: &mut [u8]) -> syscall::Result { + let bs = self.block_size() as usize; + let offset = (block as usize) * bs; + + if offset + buffer.len() > self.total_size as usize { + return Err(syscall::Error::new(EINVAL)); + } + + let preload_bytes = self.preload.len(); + + for (i, chunk) in buffer.chunks_mut(bs).enumerate() { + let block_i = block + i as u64; + let offset_i = offset + i * bs; + + // Check overlay first + if let Some(overlay) = self.overlay.get(&block_i) { + chunk.copy_from_slice(&overlay[..chunk.len()]); + continue; + } + + if offset_i + chunk.len() <= preload_bytes { + // Within preload → read from RAM + chunk.copy_from_slice(&self.preload[offset_i..offset_i + chunk.len()]); + } else { + // Beyond preload → read from physical disk + self.read_from_disk(block_i, chunk)?; + } + } + Ok(buffer.len()) + } + + fn read_from_disk(&mut self, block: u64, buffer: &mut [u8]) -> syscall::Result<()> { + // Try to open the physical disk if not already open + if self.disk_handle.is_none() { + // Try common disk scheme paths + for path in &["/scheme/disk/0", "/scheme/disk/1"] { + if let Ok(file) = OpenOptions::new().read(true).open(path) { + self.disk_handle = Some(file); + break; + } + } + } + + if let Some(ref mut disk) = self.disk_handle { + // Seek to the correct block (accounting for partition offset) + let abs_block = self.disk_block + block; + disk.read_at(buffer, abs_block * self.block_size() as u64) + .map_err(|_| syscall::Error::new(EIO))?; + Ok(()) + } else { + // No disk available yet — return what we have from preload + // (fill with zeros for regions not in preload) + buffer.fill(0); + Err(syscall::Error::new(EIO)) + } + } +} +``` + +**Problem with this approach:** `lived` starts before `ahcid` (it's at priority 10 in +init.initfs.d, while ahcid is at priority 40). So when lived first starts, there IS no +`/scheme/disk/0` to fall back to. The disk fallback would only work after ahcid initializes. + +### 4.3 Fix 3: Two-Stage Mount (Recommended) + +The cleanest fix is to change the init sequence: + +**Stage 1: lived serves the preloaded buffer (for early boot)** +- lived starts as before, serves the preload via `scheme:disk.live` +- RedoxFS does NOT mount from `disk.live` for the root filesystem +- The initfs has everything needed for early boot (lived, ahcid, basic tools) + +**Stage 2: Mount from physical disk (after drivers start)** +- After `40_drivers.target` completes, ahcid has registered `/scheme/disk/0` +- Init runs `redoxfs --uuid $REDOXFS_UUID file $REDOXFS_BLOCK` pointing to `/scheme/disk/0` +- This reads the full filesystem from the physical disk + +**Current init flow:** +``` +10_lived.service → starts lived (scheme:disk.live) +40_drivers.target → starts ahcid (scheme:disk/0) +50_rootfs.service → redoxfs mounts from... whichever disk scheme it finds first + (scans all /scheme/disk/* for matching UUID) +``` + +**The issue is timing:** `50_rootfs.service` requires `40_drivers.target`, so it should +wait for ahcid. But `redoxfs` scans ALL disk schemes, and `disk.live` matches first +(since lived starts earlier). RedoxFS finds the UUID in `disk.live` and tries to mount +from it, but the disk is too small. + +**Proposed fix:** + +1. **Make lived report the full filesystem size** by reading the RedoxFS header from + the preload buffer to determine `total_size`. Report that as `size()`. + +2. **Make lived fall through to disk reads** for out-of-bounds regions. Use a lazy-open + approach: when a read goes beyond the preload and no disk handle is open yet, try + to open `/scheme/disk/0`. If it fails, return EIO (which RedoxFS will retry). + +3. **Reduce the preload** in the bootloader. Since lived now handles disk fallback, + we can preload much less (e.g., 4-64 MiB). The preload just needs to cover the + RedoxFS header and enough metadata for the initial mount. + +--- + +## 5. Recommended Implementation Order + +### Step 1: Fix lived to report full size + disk fallback (base patch) + +Create `local/patches/base/P59-lived-disk-fallback.patch`: + +1. Add `total_size: u64` field to LiveDisk +2. Parse RedoxFS header from preload buffer to determine total filesystem size +3. Report `total_size` from `size()` instead of `preload.len()` +4. For reads beyond preload: attempt to open and read from `/scheme/disk/0` +5. Keep overlay for writes +6. Keep block_size = 512 (from P6) +7. Add env var `DISK_PHYS_BLOCK` for the partition offset on the physical disk + +### Step 2: Reduce bootloader preload cap (bootloader patch) + +Create `local/patches/bootloader/P1-reduce-live-preload.patch`: + +1. Change `max_preload` from 1024 MiB to a calculated minimum: + - Read the RedoxFS header to determine filesystem size + - Calculate the minimum preload needed: max(header + allocator extent, 4 MiB) + - Cap at 128 MiB (generous upper bound for metadata region) +2. Add `DISK_PHYS_BLOCK` env var so lived knows where the partition starts on disk + +### Step 3: Verify + +1. Build and test redbear-full ISO in QEMU with virtio-gpu +2. Verify RedoxFS mounts the full 4093 MiB filesystem +3. Verify login prompt appears +4. Verify KDE desktop loads (or at minimum, the greeter starts) + +--- + +## 6. Risk Assessment + +| Risk | Impact | Mitigation | +|------|--------|------------| +| RedoxFS header format changes between versions | lived parses header incorrectly | Use the same header parsing code as RedoxFS lib | +| ahcid not started when lived first needs disk | Read fails with ENOENT | Retry with backoff; RedoxFS mount retries automatically | +| Physical disk block offset wrong | Read corrupt data | Pass exact block offset from bootloader via env var | +| Preload too small for RedoxFS to find header | Mount fails immediately | Keep minimum preload at 4 MiB (covers any superblock) | +| Mini ISO regression | Small images broken | Test mini ISO after every change | + +--- + +## 7. Alternative Approach: Mount From Physical Disk Directly + +Instead of fixing lived, we could modify the init sequence to skip `disk.live` entirely +for the root filesystem mount: + +1. Bootloader preloads just enough for kernel + initfs (no change needed) +2. lived starts but is only used for early boot I/O +3. `50_rootfs.service` is changed to explicitly mount from `/scheme/disk/0` (via ahcid) + instead of scanning all disk schemes +4. This requires passing the disk path and block offset from bootloader to init + +**Pros:** Simpler lived (no disk fallback), cleaner architecture +**Cons:** Requires knowing which disk scheme serves the boot device; may not work if +the AHCI driver assigns a different number to the boot disk + +**Verdict:** Fix 3 (lived with disk fallback) is more robust because it works regardless +of which disk scheme is assigned. The lived approach acts as a transparent cache layer. + +--- + +## 8. Implementation Notes + +### Bootloader env vars (current) + +``` +DISK_LIVE_ADDR= +DISK_LIVE_SIZE= +REDOXFS_BLOCK=0 (always 0 for live mode) +REDOXFS_UUID= +``` + +### Bootloader env vars (proposed additions) + +``` +DISK_PHYS_BLOCK= +REDOXFS_FULL_SIZE= +``` + +### lived env vars (current) + +``` +DISK_LIVE_ADDR → phys addr to mmap +DISK_LIVE_SIZE → size to mmap (= preload size, NOT total filesystem size) +``` + +### lived env vars (proposed) + +``` +DISK_LIVE_ADDR → phys addr of preload buffer +DISK_LIVE_SIZE → size of preload buffer +DISK_PHYS_BLOCK → block offset for disk fallback reads +REDOXFS_FULL_SIZE → total filesystem size (for size() reporting) +``` diff --git a/local/patches/base/P59-lived-disk-fallback.patch b/local/patches/base/P59-lived-disk-fallback.patch new file mode 100644 index 0000000000..b5dcd41d33 --- /dev/null +++ b/local/patches/base/P59-lived-disk-fallback.patch @@ -0,0 +1,248 @@ +diff --git a/drivers/storage/lived/src/main.rs b/drivers/storage/lived/src/main.rs +index 2ca1ff27..8582e42a 100644 +--- a/drivers/storage/lived/src/main.rs ++++ b/drivers/storage/lived/src/main.rs +@@ -1,0 +2,8 @@ ++//! ++//! For live ISO boot: bootloader preloads the first N MiB of the filesystem into RAM. ++//! This daemon serves that preloaded region from RAM, and falls through to the physical ++//! disk (USB, AHCI, NVMe) for reads beyond the preload boundary. ++//! ++//! Boot order: lived(10) → drivers(40) → usbscsid(45) → rootfs(50) ++//! Since drivers load AFTER lived starts, the disk fallback is lazy: the physical disk ++//! handle is opened on the first out-of-range read, with retry backoff. +@@ -4,0 +13 @@ ++use std::cell::RefCell; +@@ -7 +15,0 @@ use std::fs::File; +- +@@ -8,0 +17 @@ use std::os::fd::AsRawFd; ++use std::sync::atomic::{AtomicBool, Ordering}; +@@ -19,0 +29,11 @@ use anyhow::{anyhow, Context}; ++/// Block size must be 512 (redoxfs BLOCK_SIZE), not PAGE_SIZE. ++/// DiskWrapper::read rejects buffers not aligned to block_size, and redoxfs reads ++/// in 512-byte chunks. ++const BLOCK_SIZE: usize = 512; ++ ++/// Maximum retries for opening the physical disk before giving up. ++/// Drivers (xhcid → usbscsid → /scheme/disk/) load between service 40-45, ++/// while lived starts at 10. Give plenty of retries. ++const DISK_OPEN_MAX_RETRIES: u32 = 60; ++const DISK_OPEN_RETRY_INTERVAL_MS: u64 = 500; ++ +@@ -22 +41,0 @@ struct LiveDisk { +- //TODO: drop overlay blocks if they match the original +@@ -23,0 +43,4 @@ struct LiveDisk { ++ full_size: u64, ++ disk_phys_offset: u64, ++ disk_file: RefCell>, ++ logged_first_fallback: AtomicBool, +@@ -27 +50,6 @@ impl LiveDisk { +- fn new(phys: usize, size: usize) -> anyhow::Result { ++ fn new( ++ phys: usize, ++ preload_size: usize, ++ full_size: u64, ++ disk_phys_offset: u64, ++ ) -> anyhow::Result { +@@ -30,2 +58,2 @@ impl LiveDisk { +- .checked_add(size) +- .context("phys + size overflow")? ++ .checked_add(preload_size) ++ .context("phys + preload_size overflow")? +@@ -33 +61 @@ impl LiveDisk { +- let size = end - start; ++ let mapped_size = end - start; +@@ -41 +69 @@ impl LiveDisk { +- length: size, ++ length: mapped_size, +@@ -47 +75 @@ impl LiveDisk { +- std::slice::from_raw_parts_mut(base as *mut u8, size) ++ std::slice::from_raw_parts_mut(base as *mut u8, mapped_size) +@@ -49,0 +78,7 @@ impl LiveDisk { ++ eprintln!( ++ "lived: preload {} MiB, full filesystem {} MiB, disk_phys_offset {:#x}", ++ preload_size / (1024 * 1024), ++ full_size / (1024 * 1024), ++ disk_phys_offset, ++ ); ++ +@@ -52,0 +88,4 @@ impl LiveDisk { ++ full_size, ++ disk_phys_offset, ++ disk_file: RefCell::new(None), ++ logged_first_fallback: AtomicBool::new(false), +@@ -54,0 +94,69 @@ impl LiveDisk { ++ ++ fn open_disk(&self) -> syscall::Result<()> { ++ if self.disk_file.borrow().is_some() { ++ return Ok(()); ++ } ++ match self.try_open_disk() { ++ Ok(file) => { ++ *self.disk_file.borrow_mut() = Some(file); ++ Ok(()) ++ } ++ Err(msg) => { ++ eprintln!("lived: disk fallback unavailable: {}", msg); ++ Err(syscall::Error::new(EIO)) ++ } ++ } ++ } ++ ++ fn try_open_disk(&self) -> Result { ++ // Try common disk scheme paths. USB boot appears as /scheme/disk/0 or /scheme/usbscsi/0. ++ // AHCI boot appears as /scheme/disk/0. NVMe appears as /scheme/disk/0. ++ let candidates = [ ++ "/scheme/disk/0", ++ "/scheme/usbscsi/0", ++ "/scheme/disk/1", ++ "/scheme/usbscsi/1", ++ ]; ++ ++ for attempt in 0..DISK_OPEN_MAX_RETRIES { ++ for path in &candidates { ++ if let Ok(file) = File::open(path) { ++ eprintln!("lived: opened physical disk at {} (attempt {})", path, attempt + 1); ++ return Ok(file); ++ } ++ } ++ ++ if attempt < DISK_OPEN_MAX_RETRIES - 1 { ++ std::thread::sleep(std::time::Duration::from_millis(DISK_OPEN_RETRY_INTERVAL_MS)); ++ } ++ } ++ ++ Err(format!( ++ "no /scheme/disk/ found after {} retries", ++ DISK_OPEN_MAX_RETRIES ++ )) ++ } ++ ++ fn read_from_disk(&self, offset: u64, buffer: &mut [u8]) -> syscall::Result { ++ let disk_offset = self.disk_phys_offset + offset; ++ ++ if !self.logged_first_fallback.swap(true, Ordering::Relaxed) { ++ eprintln!( ++ "lived: first disk fallback read at offset {} MiB (disk offset {:#x})", ++ offset / (1024 * 1024), ++ disk_offset, ++ ); ++ } ++ ++ self.open_disk()?; ++ ++ use std::io::{Read, Seek, SeekFrom}; ++ let mut disk = self.disk_file.borrow_mut(); ++ let file = disk.as_mut().unwrap(); ++ file.seek(SeekFrom::Start(disk_offset)) ++ .map_err(|_| syscall::Error::new(EIO))?; ++ file.read_exact(buffer) ++ .map_err(|_| syscall::Error::new(EIO))?; ++ ++ Ok(buffer.len()) ++ } +@@ -59 +167 @@ impl Disk for LiveDisk { +- PAGE_SIZE as u32 ++ BLOCK_SIZE as u32 +@@ -63 +171 @@ impl Disk for LiveDisk { +- self.original.len() as u64 ++ self.full_size +@@ -67,2 +175,4 @@ impl Disk for LiveDisk { +- let mut offset = (block as usize) * PAGE_SIZE; +- if offset + buffer.len() > self.original.len() { ++ let bs = self.block_size() as usize; ++ let mut offset = (block as usize) * bs; ++ ++ if offset + buffer.len() > self.full_size as usize { +@@ -71 +181,28 @@ impl Disk for LiveDisk { +- for chunk in buffer.chunks_mut(PAGE_SIZE) { ++ ++ let preload_len = self.original.len(); ++ ++ if offset + buffer.len() <= preload_len { ++ for chunk in buffer.chunks_mut(bs) { ++ match self.overlay.get(&block) { ++ Some(overlay) => { ++ chunk.copy_from_slice(&overlay[..chunk.len()]); ++ } ++ None => { ++ chunk.copy_from_slice(&self.original[offset..offset + chunk.len()]); ++ } ++ } ++ block += 1; ++ offset += bs; ++ } ++ return Ok(buffer.len()); ++ } ++ ++ if offset >= preload_len { ++ let fs_byte_offset = (block as u64) * bs as u64; ++ return self.read_from_disk(fs_byte_offset, buffer); ++ } ++ ++ let preload_remaining = preload_len - offset; ++ let (ram_part, disk_part) = buffer.split_at_mut(preload_remaining); ++ ++ for chunk in ram_part.chunks_mut(bs) { +@@ -81 +218 @@ impl Disk for LiveDisk { +- offset += PAGE_SIZE; ++ offset += bs; +@@ -82,0 +220,4 @@ impl Disk for LiveDisk { ++ ++ let disk_fs_offset = (block as u64) * bs as u64; ++ self.read_from_disk(disk_fs_offset, disk_part)?; ++ +@@ -87,2 +228,3 @@ impl Disk for LiveDisk { +- let mut offset = (block as usize) * PAGE_SIZE; +- if offset + buffer.len() > self.original.len() { ++ let bs = self.block_size() as usize; ++ let mut offset = (block as usize) * bs; ++ if offset + buffer.len() > self.full_size as usize { +@@ -91 +233 @@ impl Disk for LiveDisk { +- for chunk in buffer.chunks(PAGE_SIZE) { ++ for chunk in buffer.chunks(bs) { +@@ -93,2 +235,3 @@ impl Disk for LiveDisk { +- let offset = (block as usize) * PAGE_SIZE; +- self.original[offset..offset + PAGE_SIZE] ++ let off = (block as usize) * bs; ++ if off + bs <= self.original.len() { ++ self.original[off..off + bs] +@@ -96,0 +240,3 @@ impl Disk for LiveDisk { ++ } else { ++ vec![0u8; bs].into_boxed_slice() ++ } +@@ -100 +246 @@ impl Disk for LiveDisk { +- offset += PAGE_SIZE; ++ offset += bs; +@@ -112 +258,3 @@ fn daemon(daemon: daemon::Daemon) -> ! { +- let mut size = 0; ++ let mut preload_size = 0; ++ let mut full_size = 0u64; ++ let mut disk_phys_offset = 0u64; +@@ -129 +277 @@ fn daemon(daemon: daemon::Daemon) -> ! { +- size = usize::from_str_radix(value, 16).unwrap_or(0); ++ preload_size = usize::from_str_radix(value, 16).unwrap_or(0); +@@ -130,0 +279,3 @@ fn daemon(daemon: daemon::Daemon) -> ! { ++ ++ if name == "REDOXFS_FULL_SIZE" { ++ full_size = u64::from_str_radix(value, 16).unwrap_or(0); +@@ -133,2 +284,6 @@ fn daemon(daemon: daemon::Daemon) -> ! { +- if phys == 0 || size == 0 { +- // No live disk data, no need to say anything or exit with ++ if name == "DISK_PHYS_BLOCK" { ++ disk_phys_offset = u64::from_str_radix(value, 16).unwrap_or(0) * BLOCK_SIZE as u64; ++ } ++ } ++ ++ if phys == 0 || preload_size == 0 { +@@ -138,0 +294,4 @@ fn daemon(daemon: daemon::Daemon) -> ! { ++ if full_size == 0 { ++ full_size = preload_size as u64; ++ } ++ +@@ -152 +311 @@ fn daemon(daemon: daemon::Daemon) -> ! { +- LiveDisk::new(phys, size).unwrap_or_else(|err| { ++ LiveDisk::new(phys, preload_size, full_size, disk_phys_offset).unwrap_or_else(|err| { +@@ -160 +319 @@ fn daemon(daemon: daemon::Daemon) -> ! { +- libredox::call::setrens(0, 0).expect("nvmed: failed to enter null namespace"); ++ libredox::call::setrens(0, 0).expect("lived: failed to enter null namespace"); diff --git a/local/patches/base/P60-lived-dynamic-scheme-discovery.patch b/local/patches/base/P60-lived-dynamic-scheme-discovery.patch new file mode 100644 index 0000000000..42fa36b239 --- /dev/null +++ b/local/patches/base/P60-lived-dynamic-scheme-discovery.patch @@ -0,0 +1,118 @@ +--- a/drivers/storage/lived/src/main.rs ++++ b/drivers/storage/lived/src/main.rs +@@ -45 +45 @@ +- disk_file: RefCell>, ++ disk_path: RefCell>, +@@ -90 +90 @@ +- disk_file: RefCell::new(None), ++ disk_path: RefCell::new(None), +@@ -96 +96 @@ +- if self.disk_file.borrow().is_some() { ++ if self.disk_path.borrow().is_some() { +@@ -100,2 +100,2 @@ +- Ok(file) => { +- *self.disk_file.borrow_mut() = Some(file); ++ Ok(path) => { ++ *self.disk_path.borrow_mut() = Some(path); +@@ -111,10 +111 @@ +- fn try_open_disk(&self) -> Result { +- // Try common disk scheme paths. USB boot appears as /scheme/disk/0 or /scheme/usbscsi/0. +- // AHCI boot appears as /scheme/disk/0. NVMe appears as /scheme/disk/0. +- let candidates = [ +- "/scheme/disk/0", +- "/scheme/usbscsi/0", +- "/scheme/disk/1", +- "/scheme/usbscsi/1", +- ]; +- ++ fn try_open_disk(&self) -> Result { +@@ -122,4 +113,70 @@ +- for path in &candidates { +- if let Ok(file) = File::open(path) { +- eprintln!("lived: opened physical disk at {} (attempt {})", path, attempt + 1); +- return Ok(file); ++ if let Ok(entries) = std::fs::read_dir("/scheme") { ++ let all_schemes: Vec = entries ++ .flatten() ++ .map(|e| e.file_name().to_string_lossy().to_string()) ++ .collect(); ++ let has_disk = all_schemes ++ .iter() ++ .any(|s| s.starts_with("disk.") && s != "disk.live"); ++ if attempt == 0 || attempt == DISK_OPEN_MAX_RETRIES - 1 || has_disk { ++ eprintln!( ++ "lived: attempt {} /scheme/ = {:?} (has_disk={})", ++ attempt + 1, ++ all_schemes, ++ has_disk ++ ); ++ } ++ for name_str in &all_schemes { ++ if name_str.starts_with("disk.") && name_str != "disk.live" { ++ for idx in [0u32, 2, 1, 3, 4, 5] { ++ let path = format!("/scheme/{}/{}", name_str, idx); ++ if let Ok(mut file) = File::open(&path) { ++ use std::io::{Read, Seek, SeekFrom}; ++ let test_offset = self.disk_phys_offset + self.full_size - 4096; ++ let mut probe = vec![0u8; 4096]; ++ if file.seek(SeekFrom::Start(test_offset)).is_err() { ++ eprintln!( ++ "lived: skipping {} — seek to {:#x} failed", ++ path, test_offset ++ ); ++ continue; ++ } ++ match file.read_exact(&mut probe) { ++ Ok(()) => { ++ eprintln!( ++ "lived: validated physical disk at {} (attempt {}, verified at end {:#x})", ++ path, ++ attempt + 1, ++ test_offset ++ ); ++ return Ok(path); ++ } ++ Err(e) => { ++ eprintln!( ++ "lived: skipping {} — read at {:#x}: {}", ++ path, test_offset, e ++ ); ++ continue; ++ } ++ } ++ } else if attempt == 0 { ++ eprintln!("lived: {} not openable", path); ++ } ++ } ++ let path_root = format!("/scheme/{}", name_str); ++ if let Ok(mut file) = File::open(&path_root) { ++ use std::io::{Read, Seek, SeekFrom}; ++ let test_offset = self.disk_phys_offset + self.full_size - 4096; ++ let mut probe = vec![0u8; 4096]; ++ if file.seek(SeekFrom::Start(test_offset)).is_ok() ++ && file.read_exact(&mut probe).is_ok() ++ { ++ eprintln!( ++ "lived: validated physical disk at {} (attempt {})", ++ path_root, ++ attempt + 1 ++ ); ++ return Ok(path_root); ++ } ++ } ++ } +@@ -152,0 +210,4 @@ ++ let path = self.disk_path.borrow(); ++ let disk_path = path.as_ref().unwrap(); ++ let mut file = File::open(disk_path).map_err(|_| syscall::Error::new(EIO))?; ++ +@@ -154,2 +214,0 @@ +- let mut disk = self.disk_file.borrow_mut(); +- let file = disk.as_mut().unwrap(); +@@ -319,2 +378,4 @@ +- libredox::call::setrens(0, 0).expect("lived: failed to enter null namespace"); +- ++ // Lived must NOT call setrens(0, 0). The null namespace only contains ++ // "memory" and "pipe" (see relibc redox_setrens_v1). Lived needs ++ // ongoing access to /scheme/ for disk scheme discovery after storage ++ // drivers register their schemes asynchronously. diff --git a/local/patches/base/P61-logd-graceful-early-boot.patch b/local/patches/base/P61-logd-graceful-early-boot.patch new file mode 100644 index 0000000000..dab1658bda --- /dev/null +++ b/local/patches/base/P61-logd-graceful-early-boot.patch @@ -0,0 +1,202 @@ +diff --git a/logd/src/scheme.rs b/logd/src/scheme.rs +index 070de3d6..f5c1549a 100644 +--- a/logd/src/scheme.rs ++++ b/logd/src/scheme.rs +@@ -1,2 +1,2 @@ +-use std::collections::{BTreeMap, VecDeque}; +-use std::fs::{File, OpenOptions}; ++use std::collections::{BTreeMap, HashMap, VecDeque}; ++use std::fs::{File, OpenOptions, rename}; +@@ -5,0 +6 @@ use std::os::fd::{FromRawFd, RawFd}; ++use std::path::PathBuf; +@@ -6,0 +8 @@ use std::sync::mpsc::{self, Sender}; ++use std::time::{SystemTime, UNIX_EPOCH}; +@@ -13,0 +16,5 @@ use syscall::schemev2::NewFdFlags; ++const LOG_DIR: &str = "/var/log"; ++const MAX_LOG_SIZE: u64 = 10 * 1024 * 1024; ++const MAX_ROTATED_FILES: u32 = 5; ++const MEMORY_LOG_LIMIT: usize = 1000; ++ +@@ -31 +38 @@ enum OutputCmd { +- Log(Vec), ++ Log { context: String, line: Vec }, +@@ -34,0 +42,96 @@ enum OutputCmd { ++fn json_escape(s: &str) -> String { ++ let mut out = String::with_capacity(s.len()); ++ for c in s.chars() { ++ match c { ++ '\\' => out.push_str("\\\\"), ++ '"' => out.push_str("\\\""), ++ '\n' => out.push_str("\\n"), ++ '\r' => out.push_str("\\r"), ++ '\t' => out.push_str("\\t"), ++ c if c.is_control() => out.push_str(&format!("\\u{:04x}", c as u32)), ++ c => out.push(c), ++ } ++ } ++ out ++} ++ ++fn format_json_line(context: &str, line: &[u8]) -> Vec { ++ let now = SystemTime::now() ++ .duration_since(UNIX_EPOCH) ++ .unwrap_or_default(); ++ let secs = now.as_secs(); ++ let timestamp = format!( ++ "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z", ++ 1970 + secs / 31_557_600, ++ (secs % 31_557_600) / 2_592_000 + 1, ++ (secs % 2_592_000) / 86_400 + 1, ++ (secs % 86_400) / 3600, ++ (secs % 3600) / 60, ++ secs % 60 ++ ); ++ let text = String::from_utf8_lossy(line).trim_end_matches('\n').to_string(); ++ let (source, message) = match text.split_once(": ") { ++ Some((s, m)) => (s, m), ++ None => (context, text.as_str()), ++ }; ++ let json = format!( ++ "{{\"timestamp\":\"{}\",\"source\":\"{}\",\"message\":\"{}\"}}\n", ++ json_escape(×tamp), ++ json_escape(source), ++ json_escape(message) ++ ); ++ json.into_bytes() ++} ++ ++struct LogFile { ++ file: File, ++ path: PathBuf, ++ bytes_written: u64, ++} ++ ++impl LogFile { ++ fn open(path: PathBuf) -> std::io::Result { ++ let file = OpenOptions::new() ++ .create(true) ++ .append(true) ++ .open(&path)?; ++ let metadata = file.metadata()?; ++ Ok(LogFile { ++ file, ++ path, ++ bytes_written: metadata.len(), ++ }) ++ } ++ ++ fn write(&mut self, data: &[u8]) -> std::io::Result<()> { ++ self.file.write_all(data)?; ++ self.file.flush()?; ++ self.bytes_written += data.len() as u64; ++ Ok(()) ++ } ++ ++ fn maybe_rotate(&mut self) -> std::io::Result<()> { ++ if self.bytes_written < MAX_LOG_SIZE { ++ return Ok(()); ++ } ++ ++ drop(std::mem::replace(&mut self.file, unsafe { File::from_raw_fd(-1) })); ++ ++ for i in (1..MAX_ROTATED_FILES).rev() { ++ let old_path = self.path.with_extension(format!("log.{}", i)); ++ let new_path = self.path.with_extension(format!("log.{}", i + 1)); ++ let _ = rename(&old_path, &new_path); ++ } ++ ++ let backup_path = self.path.with_extension("log.1"); ++ let _ = rename(&self.path, &backup_path); ++ ++ self.file = OpenOptions::new() ++ .create(true) ++ .append(true) ++ .open(&self.path)?; ++ self.bytes_written = 0; ++ Ok(()) ++ } ++} ++ +@@ -43,0 +147,13 @@ impl<'sock> LogScheme<'sock> { ++ let _ = std::fs::create_dir_all("/var/log"); ++ let persistent_log: Option = OpenOptions::new() ++ .create(true) ++ .append(true) ++ .open("/var/log/system.log") ++ .ok(); ++ let mut service_logs: HashMap = HashMap::new(); ++ ++ let _ = std::fs::create_dir_all(LOG_DIR); ++ ++ ++ let json_format = std::env::var("LOGD_JSON").map_or(false, |v| v == "1"); ++ +@@ -48,0 +165,5 @@ impl<'sock> LogScheme<'sock> { ++ let mut persistent = persistent_log; ++ if let Some(ref mut f) = persistent { ++ let _ = f.write(b"--- logd started --- ++"); ++ } +@@ -51 +172,32 @@ impl<'sock> LogScheme<'sock> { +- OutputCmd::Log(line) => { ++ OutputCmd::Log { context, line } => { ++ let out_line = if json_format { ++ format_json_line(&context, &line) ++ } else { ++ line.clone() ++ }; ++ if let Some(ref mut f) = persistent { ++ let _ = f.write(&out_line); ++ let _ = f.flush(); ++ } ++ ++ let service_name = context.split(':').next().unwrap_or("unknown"); ++ if !service_name.is_empty() { ++ let log_path = PathBuf::from(LOG_DIR).join(format!("{}.log", service_name)); ++ let entry = service_logs.entry(service_name.to_string()).or_insert_with(|| { ++ LogFile::open(log_path).unwrap_or_else(|_| { ++ LogFile::open(PathBuf::from("/dev/null")).unwrap() ++ }) ++ }); ++ let _ = entry.write(&out_line); ++ let _ = entry.maybe_rotate(); ++ } ++ ++ let system_path = PathBuf::from(LOG_DIR).join("system.log"); ++ let system_entry = service_logs.entry("system".to_string()).or_insert_with(|| { ++ LogFile::open(system_path).unwrap_or_else(|_| { ++ LogFile::open(PathBuf::from("/dev/null")).unwrap() ++ }) ++ }); ++ let _ = system_entry.write(&out_line); ++ let _ = system_entry.maybe_rotate(); ++ +@@ -53 +205 @@ impl<'sock> LogScheme<'sock> { +- let _ = file.write(&line); ++ let _ = file.write(&out_line); +@@ -56,3 +208,2 @@ impl<'sock> LogScheme<'sock> { +- logs.push_back(line); +- // Keep a limited amount of logs for backfilling to bound memory usage +- while logs.len() > 1000 { ++ logs.push_back(out_line); ++ while logs.len() > MEMORY_LOG_LIMIT { +@@ -68 +218,0 @@ impl<'sock> LogScheme<'sock> { +- +@@ -83 +232,0 @@ impl<'sock> LogScheme<'sock> { +- // FIXME currently possible as /scheme/log/kernel presents a snapshot of the log queue +@@ -118 +266,0 @@ impl<'sock> LogScheme<'sock> { +- // Writing to the kernel debug log never blocks +@@ -124 +272,4 @@ impl<'sock> LogScheme<'sock> { +- .send(OutputCmd::Log(mem::take(handle_buf))) ++ .send(OutputCmd::Log { ++ context: context.to_string(), ++ line: mem::take(handle_buf), ++ }) +@@ -173,3 +323,0 @@ impl<'sock> SchemeSync for LogScheme<'sock> { +- +- // TODO +- +@@ -244,3 +391,0 @@ impl<'sock> SchemeSync for LogScheme<'sock> { +- +- //TODO: flush remaining data? +- diff --git a/local/patches/bootloader/P5-live-preload-cap-128mib.patch b/local/patches/bootloader/P5-live-preload-cap-128mib.patch new file mode 100644 index 0000000000..6067f410f9 --- /dev/null +++ b/local/patches/bootloader/P5-live-preload-cap-128mib.patch @@ -0,0 +1,48 @@ +diff --git a/src/main.rs b/src/main.rs +index 78dabb0..a41086e 100644 +--- a/src/main.rs ++++ b/src/main.rs +@@ -557,0 +558 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { ++ let disk_block = fs.block; +@@ -559 +560,13 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- print!("live: 0/{} MiB", size / MIBI as u64); ++ let max_preload: u64 = 128 * MIBI as u64; ++ let preload_size = if size > max_preload { ++ println!( ++ "live: filesystem is {} MiB, capping preload at {} MiB", ++ size / MIBI as u64, ++ max_preload / MIBI as u64 ++ ); ++ max_preload ++ } else { ++ size ++ }; ++ ++ print!("live: 0/{} MiB", preload_size / MIBI as u64); +@@ -561 +574 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- let live_size = match usize::try_from(size) { ++ let live_size = match usize::try_from(preload_size) { +@@ -593 +606 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- print!("\rlive: {}/{} MiB", i / MIBI as u64, size / MIBI as u64); ++ print!("\rlive: {}/{} MiB", i / MIBI as u64, preload_size / MIBI as u64); +@@ -600 +613,10 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- println!("\rlive: {}/{} MiB", i / MIBI as u64, size / MIBI as u64); ++ println!("\rlive: {}/{} MiB", i / MIBI as u64, preload_size / MIBI as u64); ++ ++ if preload_size < size { ++ println!( ++ "live: preloaded {} MiB of {} MiB filesystem (remaining {} MiB from disk)", ++ preload_size / MIBI as u64, ++ size / MIBI as u64, ++ (size - preload_size) / MIBI as u64 ++ ); ++ } +@@ -613 +635 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- Some(live) ++ Some((disk_block, size, live)) +@@ -672 +694 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- if let Some(live) = live_opt { ++ if let Some((disk_block, fs_size, live)) = live_opt { +@@ -674,0 +697,2 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { ++ writeln!(w, "DISK_PHYS_BLOCK={:016x}", disk_block).unwrap(); ++ writeln!(w, "REDOXFS_FULL_SIZE={:016x}", fs_size).unwrap(); diff --git a/local/patches/bootloader/P6-full-ramdisk-preload.patch b/local/patches/bootloader/P6-full-ramdisk-preload.patch new file mode 100644 index 0000000000..6042e9b724 --- /dev/null +++ b/local/patches/bootloader/P6-full-ramdisk-preload.patch @@ -0,0 +1,91 @@ +diff --git a/src/arch/x86/x64.rs b/src/arch/x86/x64.rs +index a0a275a..cad4592 100644 +--- a/src/arch/x86/x64.rs ++++ b/src/arch/x86/x64.rs +@@ -46 +46 @@ pub unsafe fn paging_create(os: &impl Os, kernel_phys: u64, kernel_size: u64) -> +- for pdp_i in 0..8 { ++ for pdp_i in 0..64 { +@@ -103 +103 @@ pub unsafe fn paging_framebuffer( +- if framebuffer_phys + framebuffer_size <= 0x2_0000_0000 { ++ if framebuffer_phys + framebuffer_size <= 0x10_0000_0000 { +diff --git a/src/main.rs b/src/main.rs +index a41086e..1ce4bf3 100644 +--- a/src/main.rs ++++ b/src/main.rs +@@ -560,11 +560 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- let max_preload: u64 = 128 * MIBI as u64; +- let preload_size = if size > max_preload { +- println!( +- "live: filesystem is {} MiB, capping preload at {} MiB", +- size / MIBI as u64, +- max_preload / MIBI as u64 +- ); +- max_preload +- } else { +- size +- }; ++ let mut preload_size: u64 = size; +@@ -572,4 +562,5 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- print!("live: 0/{} MiB", preload_size / MIBI as u64); +- +- let live_size = match usize::try_from(preload_size) { +- Ok(live_size) => live_size, ++ let mut ptr = ptr::null_mut(); ++ if live { ++ ptr = os.alloc_zeroed_page_aligned( ++ match usize::try_from(preload_size) { ++ Ok(s) => s, +@@ -581 +572,19 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- }; ++ } ++ ); ++ if ptr.is_null() && live { ++ println!( ++ "\rlive: unable to allocate {} MiB, halving...", ++ preload_size / MIBI as u64 ++ ); ++ let floor: u64 = 128 * MIBI as u64; ++ while preload_size > floor { ++ preload_size /= 2; ++ if let Ok(smaller) = usize::try_from(preload_size) { ++ ptr = os.alloc_zeroed_page_aligned(smaller); ++ if !ptr.is_null() { ++ break; ++ } ++ } ++ } ++ } ++ } +@@ -583,6 +592 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { +- let ptr = if live { +- os.alloc_zeroed_page_aligned(live_size) +- } else { +- ptr::null_mut() +- }; +- if live && ptr.is_null() { ++ if ptr.is_null() { +@@ -595,0 +600,11 @@ fn main(os: &impl Os) -> (usize, u64, KernelArgs) { ++ print!("live: 0/{} MiB", preload_size / MIBI as u64); ++ ++ let live_size = match usize::try_from(preload_size) { ++ Ok(live_size) => live_size, ++ Err(_) => { ++ println!("\rlive: disabled (image too large for bootloader address space)"); ++ live = false; ++ 0 ++ } ++ }; ++ +diff --git a/src/os/uefi/mod.rs b/src/os/uefi/mod.rs +index d0b2cf1..dacead6 100644 +--- a/src/os/uefi/mod.rs ++++ b/src/os/uefi/mod.rs +@@ -48,2 +48 @@ pub(crate) fn alloc_zeroed_page_aligned(size: usize) -> *mut u8 { +- // Max address mapped by src/arch paging code (8 GiB) +- let mut ptr = 0x2_0000_0000; ++ let mut ptr = 0; +@@ -51,2 +50,2 @@ pub(crate) fn alloc_zeroed_page_aligned(size: usize) -> *mut u8 { +- 1, // AllocateMaxAddress +- MemoryType::EfiRuntimeServicesData, // Keeps this memory out of free space list ++ 0, // AllocateAnyPages ++ MemoryType::EfiLoaderData, // Valid until ExitBootServices diff --git a/local/patches/kernel/P26-debug-display-scroll.patch b/local/patches/kernel/P26-debug-display-scroll.patch new file mode 100644 index 0000000000..0adfcdedb3 --- /dev/null +++ b/local/patches/kernel/P26-debug-display-scroll.patch @@ -0,0 +1,107 @@ +diff --git a/src/devices/graphical_debug/debug.rs b/src/devices/graphical_debug/debug.rs +index 4b684c8a..e3fe0472 100644 +--- a/src/devices/graphical_debug/debug.rs ++++ b/src/devices/graphical_debug/debug.rs +@@ -29,0 +30,3 @@ impl DebugDisplay { ++ const CHAR_WIDTH: usize = 8; ++ const CHAR_HEIGHT: usize = 16; ++ +@@ -43,2 +46,2 @@ impl DebugDisplay { +- let w = display.width / 8; +- let h = display.height / 16; ++ let w = display.width / Self::CHAR_WIDTH; ++ let h = display.height / Self::CHAR_HEIGHT; +@@ -54,0 +58,21 @@ impl DebugDisplay { ++ fn scroll_up(&mut self) { ++ let stride = self.display.stride; ++ let width = self.display.width; ++ let total_height = self.display.height; ++ let scroll_px = Self::CHAR_HEIGHT; ++ ++ unsafe { ++ let ptr = self.display.onscreen_ptr; ++ for row in 0..total_height - scroll_px { ++ ptr::copy( ++ ptr.add((row + scroll_px) * stride), ++ ptr.add(row * stride), ++ width, ++ ); ++ } ++ for row in total_height - scroll_px..total_height { ++ ptr::write_bytes(ptr.add(row * stride), 0, width); ++ } ++ } ++ } ++ +@@ -59 +83,5 @@ impl DebugDisplay { +- self.y = (self.y + 1) % self.h; ++ self.y += 1; ++ if self.y >= self.h { ++ self.scroll_up(); ++ self.y = self.h - 1; ++ } +@@ -67 +94,0 @@ impl DebugDisplay { +- // Byte 0x1B starts ESC sequence +@@ -72 +98,0 @@ impl DebugDisplay { +- // Ignore other nonprintable characters +@@ -77 +102,0 @@ impl DebugDisplay { +- // '[' after ESC starts CSI sequence +@@ -82 +106,0 @@ impl DebugDisplay { +- // Capture any bytes after ESC +@@ -87 +110,0 @@ impl DebugDisplay { +- // Byte 0x40 to 0x7E ends CSI +@@ -92 +114,0 @@ impl DebugDisplay { +- // Capture any bytes after CSI +@@ -96 +117,0 @@ impl DebugDisplay { +- // Allow any other bytes +@@ -102 +122,0 @@ impl DebugDisplay { +- self.clear_row((self.y + 1) % self.h); +@@ -105 +125 @@ impl DebugDisplay { +- self.char(self.x * 8, self.y * 16, b as char, 0xFFFFFF); ++ self.char(self.x * Self::CHAR_WIDTH, self.y * Self::CHAR_HEIGHT, b as char, 0xFFFFFF); +@@ -112 +132 @@ impl DebugDisplay { +- for row in y * 16..(y + 1) * 16 { ++ for row in y * Self::CHAR_HEIGHT..(y + 1) * Self::CHAR_HEIGHT { +@@ -123 +142,0 @@ impl DebugDisplay { +- /// Draw a character +@@ -125,7 +144,8 @@ impl DebugDisplay { +- if x + 8 <= self.display.width && y + 16 <= self.display.height { +- let phys_y = y % self.display.height; +- let mut dst = unsafe { +- self.display +- .onscreen_ptr +- .add(phys_y * self.display.stride + x) +- }; ++ if x + Self::CHAR_WIDTH > self.display.width || y + Self::CHAR_HEIGHT > self.display.height { ++ return; ++ } ++ ++ let font_i = Self::CHAR_HEIGHT * (character as usize); ++ if font_i + Self::CHAR_HEIGHT > FONT.len() { ++ return; ++ } +@@ -133,6 +152,0 @@ impl DebugDisplay { +- let font_i = 16 * (character as usize); +- if font_i + 16 <= FONT.len() { +- for row in 0..16 { +- let row_data = FONT[font_i + row]; +- for col in 0..8 { +- if (row_data >> (7 - col)) & 1 == 1 { +@@ -139,0 +154,7 @@ impl DebugDisplay { ++ let ptr = self.display.onscreen_ptr; ++ let stride = self.display.stride; ++ for row in 0..Self::CHAR_HEIGHT { ++ let row_data = FONT[font_i + row]; ++ let dst = ptr.add((y + row) * stride + x); ++ for col in 0..Self::CHAR_WIDTH { ++ if (row_data >> (Self::CHAR_WIDTH - 1 - col)) & 1 == 1 { +@@ -144,9 +164,0 @@ impl DebugDisplay { +- +- let next_phys_y = (phys_y + row + 1) % self.display.height; +- dst = unsafe { +- self.display +- .onscreen_ptr +- .add(next_phys_y * self.display.stride + x) +- }; +- } +- } diff --git a/local/recipes/gpu/redox-drm/source/src/main.rs b/local/recipes/gpu/redox-drm/source/src/main.rs index a6ab74b831..e814e50265 100644 --- a/local/recipes/gpu/redox-drm/source/src/main.rs +++ b/local/recipes/gpu/redox-drm/source/src/main.rs @@ -125,6 +125,8 @@ fn run(daemon: daemon::Daemon) -> Result<()> { daemon.ready(); let mut handler = ReadinessBased::new(&socket, 16); + let mut scheme_err_logged = false; + let mut response_err_logged = false; loop { match handler.read_requests() { Ok(true) => {} @@ -133,7 +135,10 @@ fn run(daemon: daemon::Daemon) -> Result<()> { break; } Err(e) => { - error!("redox-drm: failed to receive scheme request: {}", e); + if !scheme_err_logged { + error!("redox-drm: failed to receive scheme request: {} (suppressing further errors)", e); + scheme_err_logged = true; + } continue; } } @@ -141,7 +146,10 @@ fn run(daemon: daemon::Daemon) -> Result<()> { handler.process_requests(|| drm_scheme.lock().expect("DRM scheme state poisoned")); if let Err(e) = handler.write_responses() { - error!("redox-drm: failed to write scheme responses: {}", e); + if !response_err_logged { + error!("redox-drm: failed to write scheme responses: {} (suppressing further errors)", e); + response_err_logged = true; + } } } diff --git a/local/recipes/kde/kf6-attica/source/CMakeLists.txt b/local/recipes/kde/kf6-attica/source/CMakeLists.txt index 43662f229f..02a0964456 100644 --- a/local/recipes/kde/kf6-attica/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-attica/source/CMakeLists.txt @@ -57,7 +57,7 @@ add_subdirectory(src) # Enable unit testing if (BUILD_TESTING) -############################################################ add_subdirectory(autotests) +############################################################# add_subdirectory(autotests) add_subdirectory(tests) endif () diff --git a/local/recipes/kde/kf6-extra-cmake-modules/recipe.toml b/local/recipes/kde/kf6-extra-cmake-modules/recipe.toml index 5d84edf137..8d93d17737 100644 --- a/local/recipes/kde/kf6-extra-cmake-modules/recipe.toml +++ b/local/recipes/kde/kf6-extra-cmake-modules/recipe.toml @@ -19,6 +19,7 @@ cmake "${COOKBOOK_SOURCE}" \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_PREFIX_PATH="${COOKBOOK_SYSROOT}" \ -DBUILD_TESTING=OFF \ + -DBUILD_DOC=OFF \ -DBUILD_QCH=OFF \ -Wno-dev diff --git a/local/recipes/kde/kf6-kcmutils/source/CMakeLists.txt b/local/recipes/kde/kf6-kcmutils/source/CMakeLists.txt index 5486c6e9aa..990ed0bd7e 100644 --- a/local/recipes/kde/kf6-kcmutils/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kcmutils/source/CMakeLists.txt @@ -144,6 +144,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) # shall we use DBus? # enabled per default on Linux & BSD systems diff --git a/local/recipes/kde/kf6-kcolorscheme/source/CMakeLists.txt b/local/recipes/kde/kf6-kcolorscheme/source/CMakeLists.txt index df32dde4a1..ff2b2a1df3 100644 --- a/local/recipes/kde/kf6-kcolorscheme/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kcolorscheme/source/CMakeLists.txt @@ -122,6 +122,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) set(EXCLUDE_DEPRECATED_BEFORE_AND_AT 0 CACHE STRING "Control the range of deprecated API excluded from the build [default=0].") diff --git a/local/recipes/kde/kf6-kcompletion/source/CMakeLists.txt b/local/recipes/kde/kf6-kcompletion/source/CMakeLists.txt index b5d2926e5e..c22d64ab7d 100644 --- a/local/recipes/kde/kf6-kcompletion/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kcompletion/source/CMakeLists.txt @@ -113,6 +113,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(KF6Codecs ${KF_DEP_VERSION} REQUIRED) find_package(KF6Config ${KF_DEP_VERSION} REQUIRED) diff --git a/local/recipes/kde/kf6-kconfigwidgets/source/CMakeLists.txt b/local/recipes/kde/kf6-kconfigwidgets/source/CMakeLists.txt index 6b4be4cd03..2c4023b6da 100644 --- a/local/recipes/kde/kf6-kconfigwidgets/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kconfigwidgets/source/CMakeLists.txt @@ -116,6 +116,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) # shall we use DBus? # enabled per default on Linux & BSD systems diff --git a/local/recipes/kde/kf6-kdeclarative/source/CMakeLists.txt b/local/recipes/kde/kf6-kdeclarative/source/CMakeLists.txt index afbf67049a..234131d97a 100644 --- a/local/recipes/kde/kf6-kdeclarative/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kdeclarative/source/CMakeLists.txt @@ -32,7 +32,7 @@ find_package(KF6GuiAddons ${KF_DEP_VERSION} REQUIRED) if(NOT WIN32 AND NOT APPLE AND NOT ANDROID AND NOT REDOX) -################################################################################### find_package(KF6GlobalAccel ${KF_DEP_VERSION} REQUIRED) +#################################################################################### find_package(KF6GlobalAccel ${KF_DEP_VERSION} REQUIRED) set(HAVE_KGLOBALACCEL TRUE) else() set(HAVE_KGLOBALACCEL FALSE) diff --git a/local/recipes/kde/kf6-kiconthemes/source/CMakeLists.txt b/local/recipes/kde/kf6-kiconthemes/source/CMakeLists.txt index ed68fd59cc..6f735dc093 100644 --- a/local/recipes/kde/kf6-kiconthemes/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kiconthemes/source/CMakeLists.txt @@ -136,6 +136,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6Svg ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE) # shall we use DBus? diff --git a/local/recipes/kde/kf6-kitemmodels/source/CMakeLists.txt b/local/recipes/kde/kf6-kitemmodels/source/CMakeLists.txt index 82e3b86302..21a36d8457 100644 --- a/local/recipes/kde/kf6-kitemmodels/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kitemmodels/source/CMakeLists.txt @@ -38,7 +38,7 @@ set_package_properties(Qt6Qml PROPERTIES ) if (TARGET Qt6::Qml) -############################################################## include(ECMQmlModule) +############################################################### include(ECMQmlModule) endif() set(EXCLUDE_DEPRECATED_BEFORE_AND_AT 0 CACHE STRING "Control the range of deprecated API excluded from the build [default=0].") diff --git a/local/recipes/kde/kf6-kitemmodels/source/src/CMakeLists.txt b/local/recipes/kde/kf6-kitemmodels/source/src/CMakeLists.txt index abe3a7ba8e..1a4125afa2 100644 --- a/local/recipes/kde/kf6-kitemmodels/source/src/CMakeLists.txt +++ b/local/recipes/kde/kf6-kitemmodels/source/src/CMakeLists.txt @@ -1,6 +1,6 @@ add_subdirectory(core) if (TARGET Qt6::Qml) -############################################################# add_subdirectory(qml) +############################################################## add_subdirectory(qml) endif() ecm_qt_install_logging_categories( diff --git a/local/recipes/kde/kf6-kitemviews/source/CMakeLists.txt b/local/recipes/kde/kf6-kitemviews/source/CMakeLists.txt index 6f2ea559da..d47ab5382b 100644 --- a/local/recipes/kde/kf6-kitemviews/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kitemviews/source/CMakeLists.txt @@ -102,6 +102,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) set(EXCLUDE_DEPRECATED_BEFORE_AND_AT 0 CACHE STRING "Control the range of deprecated API excluded from the build [default=0].") diff --git a/local/recipes/kde/kf6-kjobwidgets/source/CMakeLists.txt b/local/recipes/kde/kf6-kjobwidgets/source/CMakeLists.txt index 69e2d1014d..7734a7569f 100644 --- a/local/recipes/kde/kf6-kjobwidgets/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kjobwidgets/source/CMakeLists.txt @@ -102,6 +102,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) if(NOT WIN32 AND NOT APPLE AND NOT ANDROID AND NOT HAIKU) option(WITH_X11 "Build with support for QX11Info::appUserTime()" ON) diff --git a/local/recipes/kde/kf6-ktextwidgets/source/CMakeLists.txt b/local/recipes/kde/kf6-ktextwidgets/source/CMakeLists.txt index b99e0c5ef0..9f3d4747ec 100644 --- a/local/recipes/kde/kf6-ktextwidgets/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-ktextwidgets/source/CMakeLists.txt @@ -117,6 +117,7 @@ find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) +find_package(Qt6GuiPrivate ${REQUIRED_QT_VERSION} REQUIRED) if (WITH_TEXT_TO_SPEECH) find_package(Qt6 ${REQUIRED_QT_VERSION} CONFIG REQUIRED TextToSpeech) diff --git a/local/recipes/kde/kf6-kwayland/source/CMakeLists.txt b/local/recipes/kde/kf6-kwayland/source/CMakeLists.txt index cc8b60ccdb..3191c0b94b 100644 --- a/local/recipes/kde/kf6-kwayland/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-kwayland/source/CMakeLists.txt @@ -122,6 +122,7 @@ find_package(Qt6WaylandClientPrivate REQUIRED) find_package(Qt6WaylandClientPrivate REQUIRED) find_package(Qt6WaylandClientPrivate REQUIRED) find_package(Qt6WaylandClientPrivate REQUIRED) +find_package(Qt6WaylandClientPrivate REQUIRED) set_package_properties(Wayland PROPERTIES TYPE REQUIRED ) diff --git a/local/recipes/kde/kf6-kxmlgui/source/src/kswitchlanguagedialog_p.cpp b/local/recipes/kde/kf6-kxmlgui/source/src/kswitchlanguagedialog_p.cpp index 5e053a1ccd..7e1a185917 100644 --- a/local/recipes/kde/kf6-kxmlgui/source/src/kswitchlanguagedialog_p.cpp +++ b/local/recipes/kde/kf6-kxmlgui/source/src/kswitchlanguagedialog_p.cpp @@ -74,10 +74,10 @@ void initializeLanguages() // Ideally setting the LANGUAGE would change the default QLocale too // but unfortunately this is too late since the QCoreApplication constructor // already created a QLocale at this stage so we need to set the reset it -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // by triggering the creation and destruction of a QSystemLocale +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // by triggering the creation and destruction of a QSystemLocale // this is highly dependent on Qt internals, so may break, but oh well -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// QSystemLocale *dummy = new QSystemLocale(); -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete dummy; +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// QSystemLocale *dummy = new QSystemLocale(); +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// delete dummy; } } diff --git a/local/recipes/kde/kf6-pty/source/CMakeLists.txt b/local/recipes/kde/kf6-pty/source/CMakeLists.txt index 94e6cd1495..485ba21ec6 100644 --- a/local/recipes/kde/kf6-pty/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-pty/source/CMakeLists.txt @@ -65,9 +65,9 @@ ecm_set_disabled_deprecation_versions( ) add_subdirectory( src ) -#################################if (BUILD_TESTING) -################################# add_subdirectory( autotests ) -#################################endif() +##################################if (BUILD_TESTING) +################################## add_subdirectory( autotests ) +##################################endif() if (BUILD_QCH) ecm_install_qch_export( diff --git a/local/recipes/kde/kf6-solid/source/CMakeLists.txt b/local/recipes/kde/kf6-solid/source/CMakeLists.txt index c5662d88ea..2e4e94c22f 100644 --- a/local/recipes/kde/kf6-solid/source/CMakeLists.txt +++ b/local/recipes/kde/kf6-solid/source/CMakeLists.txt @@ -78,7 +78,7 @@ set_package_properties(PList PROPERTIES if (CMAKE_SYSTEM_NAME MATCHES Linux) # Used by the UDisks backend on Linux - ####################################################################################################find_package(LibMount) + #####################################################################################################find_package(LibMount) set_package_properties(LibMount PROPERTIES TYPE REQUIRED) endif() diff --git a/local/recipes/kde/kwin/source/src/backends/libinput/device.cpp b/local/recipes/kde/kwin/source/src/backends/libinput/device.cpp index 610f880f5d..4b0fd53243 100644 --- a/local/recipes/kde/kwin/source/src/backends/libinput/device.cpp +++ b/local/recipes/kde/kwin/source/src/backends/libinput/device.cpp @@ -124,6 +124,7 @@ #include #include #include +#include #include "config-kwin.h" diff --git a/local/recipes/kde/kwin/source/src/helpers/CMakeLists.txt b/local/recipes/kde/kwin/source/src/helpers/CMakeLists.txt index dd7da03f83..a36d265785 100644 --- a/local/recipes/kde/kwin/source/src/helpers/CMakeLists.txt +++ b/local/recipes/kde/kwin/source/src/helpers/CMakeLists.txt @@ -1,2 +1,2 @@ -#####################################################################################################################add_subdirectory(killer) # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only +######################################################################################################################add_subdirectory(killer) # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only # disabled: X11-only add_subdirectory(wayland_wrapper) diff --git a/local/recipes/kde/kwin/source/src/helpers/wayland_wrapper/wl-socket.c b/local/recipes/kde/kwin/source/src/helpers/wayland_wrapper/wl-socket.c index fd6b3b9d67..af832c5795 100644 --- a/local/recipes/kde/kwin/source/src/helpers/wayland_wrapper/wl-socket.c +++ b/local/recipes/kde/kwin/source/src/helpers/wayland_wrapper/wl-socket.c @@ -349,6 +349,9 @@ #ifndef SUN_LEN #define SUN_LEN(s) (sizeof(*(s)) - sizeof((s)->sun_path) + strnlen((s)->sun_path, sizeof((s)->sun_path))) #endif +#ifndef SUN_LEN +#define SUN_LEN(s) (sizeof(*(s)) - sizeof((s)->sun_path) + strnlen((s)->sun_path, sizeof((s)->sun_path))) +#endif /* KWin - the KDE window manager This file is part of the KDE project. diff --git a/local/recipes/kde/kwin/source/src/plugins/systembell/CMakeLists.txt b/local/recipes/kde/kwin/source/src/plugins/systembell/CMakeLists.txt index 164d89877b..8e49e85aed 100644 --- a/local/recipes/kde/kwin/source/src/plugins/systembell/CMakeLists.txt +++ b/local/recipes/kde/kwin/source/src/plugins/systembell/CMakeLists.txt @@ -10,5 +10,5 @@ target_link_libraries(systembell PRIVATE KF6::GlobalAccel KF6::I18n - $,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,Canberra::Canberra,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,> + $,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,$,Canberra::Canberra,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,>,> ) diff --git a/local/recipes/kde/kwin/source/src/tabletmodemanager.cpp b/local/recipes/kde/kwin/source/src/tabletmodemanager.cpp index 74bf4e35a9..eff51763fd 100644 --- a/local/recipes/kde/kwin/source/src/tabletmodemanager.cpp +++ b/local/recipes/kde/kwin/source/src/tabletmodemanager.cpp @@ -124,6 +124,7 @@ #include #include #include +#include #include "backends/libinput/device.h" #include "core/inputdevice.h" diff --git a/local/recipes/kde/kwin/source/src/utils/ramfile.cpp b/local/recipes/kde/kwin/source/src/utils/ramfile.cpp index bc57b20022..091fad38ce 100644 --- a/local/recipes/kde/kwin/source/src/utils/ramfile.cpp +++ b/local/recipes/kde/kwin/source/src/utils/ramfile.cpp @@ -700,6 +700,12 @@ #define F_SEAL_SHRINK 0x0002 #define F_SEAL_GROW 0x0004 #define F_SEAL_WRITE 0x0008 +#define F_ADD_SEALS 1033 +#define F_GET_SEALS 1034 +#define F_SEAL_SEAL 0x0001 +#define F_SEAL_SHRINK 0x0002 +#define F_SEAL_GROW 0x0004 +#define F_SEAL_WRITE 0x0008 /* KWin - the KDE window manager This file is part of the KDE project. diff --git a/local/recipes/qt/qtbase/source/mkspecs/common/posix/qplatformdefs.h b/local/recipes/qt/qtbase/source/mkspecs/common/posix/qplatformdefs.h index 1118bffe1b..510fdf9558 100644 --- a/local/recipes/qt/qtbase/source/mkspecs/common/posix/qplatformdefs.h +++ b/local/recipes/qt/qtbase/source/mkspecs/common/posix/qplatformdefs.h @@ -198,6 +198,14 @@ #endif #endif +#ifdef Q_OS_REDOX +#undef QT_USE_XOPEN_LFS_EXTENSIONS +#undef QT_LARGEFILE_SUPPORT +#ifndef O_LARGEFILE +#define O_LARGEFILE 0 +#endif +#endif + // Copyright (C) 2016 The Qt Company Ltd. // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only diff --git a/local/recipes/qt/qtbase/source/src/corelib/CMakeLists.txt b/local/recipes/qt/qtbase/source/src/corelib/CMakeLists.txt index 465898a718..370d732674 100644 --- a/local/recipes/qt/qtbase/source/src/corelib/CMakeLists.txt +++ b/local/recipes/qt/qtbase/source/src/corelib/CMakeLists.txt @@ -1375,6 +1375,13 @@ qt_internal_extend_target(Core CONDITION REDOX io/qstorageinfo_unix.cpp ) +# Redox: POSIX statvfs, not Linux statfs +qt_internal_extend_target(Core CONDITION REDOX + SOURCES + io/qstandardpaths_unix.cpp + io/qstorageinfo_unix.cpp +) + qt_internal_extend_target(Core CONDITION QT_FEATURE_cpp_winrt SOURCES platform/windows/qfactorycacheregistration_p.h @@ -1578,6 +1585,13 @@ qt_internal_extend_target(Core CONDITION REDOX io/qstorageinfo_unix.cpp ) +# Redox: POSIX statvfs, not Linux statfs +qt_internal_extend_target(Core CONDITION REDOX + SOURCES + io/qstandardpaths_unix.cpp + io/qstorageinfo_unix.cpp +) + qt_internal_extend_target(Core CONDITION QT_FEATURE_itemmodel SOURCES itemmodels/qabstractitemmodel.cpp itemmodels/qabstractitemmodel.h itemmodels/qabstractitemmodel_p.h diff --git a/local/recipes/qt/qtbase/source/src/corelib/global/qtypes.h b/local/recipes/qt/qtbase/source/src/corelib/global/qtypes.h index 5f0fdfcad2..303dec0095 100644 --- a/local/recipes/qt/qtbase/source/src/corelib/global/qtypes.h +++ b/local/recipes/qt/qtbase/source/src/corelib/global/qtypes.h @@ -202,6 +202,7 @@ static_assert(std::is_signed_v, #include #include #include +#include #ifndef static_assert #define static_assert _Static_assert #endif diff --git a/local/recipes/qt/qtbase/source/src/network/socket/qnativesocketengine_unix.cpp b/local/recipes/qt/qtbase/source/src/network/socket/qnativesocketengine_unix.cpp index ff6710965d..4c020a3dcc 100644 --- a/local/recipes/qt/qtbase/source/src/network/socket/qnativesocketengine_unix.cpp +++ b/local/recipes/qt/qtbase/source/src/network/socket/qnativesocketengine_unix.cpp @@ -1146,6 +1146,7 @@ qint64 QNativeSocketEnginePrivate::nativeSendDatagram(const char *data, qint64 l #ifdef IPV6_HOPLIMIT #ifdef IPV6_HOPLIMIT #ifdef IPV6_HOPLIMIT +#ifdef IPV6_HOPLIMIT #ifdef IPV6_HOPLIMIT if (header.hopLimit != -1) { msg.msg_controllen += CMSG_SPACE(sizeof(int)); @@ -1179,6 +1180,7 @@ qint64 QNativeSocketEnginePrivate::nativeSendDatagram(const char *data, qint64 l #endif #endif #endif +#endif #endif if (header.ifindex != 0 || !header.senderAddress.isNull()) { struct in6_pktinfo *data = reinterpret_cast(CMSG_DATA(cmsgptr)); diff --git a/local/recipes/qt/qtbase/source/src/network/socket/qnet_unix_p.h b/local/recipes/qt/qtbase/source/src/network/socket/qnet_unix_p.h index 41aa064214..808f981005 100644 --- a/local/recipes/qt/qtbase/source/src/network/socket/qnet_unix_p.h +++ b/local/recipes/qt/qtbase/source/src/network/socket/qnet_unix_p.h @@ -46,6 +46,7 @@ #include #include #include +#include #include #if defined(Q_OS_VXWORKS) diff --git a/local/recipes/qt/qtbase/source/src/plugins/platforms/wayland/hardwareintegration/qwaylandclientbufferintegration_p.h b/local/recipes/qt/qtbase/source/src/plugins/platforms/wayland/hardwareintegration/qwaylandclientbufferintegration_p.h index bafc762780..3b32598b30 100644 --- a/local/recipes/qt/qtbase/source/src/plugins/platforms/wayland/hardwareintegration/qwaylandclientbufferintegration_p.h +++ b/local/recipes/qt/qtbase/source/src/plugins/platforms/wayland/hardwareintegration/qwaylandclientbufferintegration_p.h @@ -76,6 +76,7 @@ public: #if QT_CONFIG(opengl) #if QT_CONFIG(opengl) #if QT_CONFIG(opengl) +#if QT_CONFIG(opengl) #if QT_CONFIG(opengl) virtual QPlatformOpenGLContext *createPlatformOpenGLContext(const QSurfaceFormat &glFormat, QPlatformOpenGLContext *share) const = 0; #endif /* QT_CONFIG(opengl) */ @@ -102,6 +103,7 @@ public: #endif /* QT_CONFIG(opengl) */ #endif /* QT_CONFIG(opengl) */ #endif /* QT_CONFIG(opengl) */ +#endif /* QT_CONFIG(opengl) */ #endif /* QT_CONFIG(opengl) */ virtual bool canCreatePlatformOffscreenSurface() const { return false; } #if QT_CONFIG(opengl) @@ -139,6 +141,7 @@ public: #if QT_CONFIG(opengl) #if QT_CONFIG(opengl) #if QT_CONFIG(opengl) +#if QT_CONFIG(opengl) #if QT_CONFIG(opengl) virtual void *nativeResourceForContext(NativeResource /*resource*/, QPlatformOpenGLContext */*context*/) { return nullptr; } #endif /* QT_CONFIG(opengl) */ @@ -166,6 +169,7 @@ public: #endif /* QT_CONFIG(opengl) */ #endif /* QT_CONFIG(opengl) */ #endif /* QT_CONFIG(opengl) */ +#endif /* QT_CONFIG(opengl) */ }; } diff --git a/local/recipes/system/driver-manager/source/src/main.rs b/local/recipes/system/driver-manager/source/src/main.rs index 1d1291f4a4..035daae8ea 100644 --- a/local/recipes/system/driver-manager/source/src/main.rs +++ b/local/recipes/system/driver-manager/source/src/main.rs @@ -49,6 +49,42 @@ impl log::Log for StderrLogger { fn flush(&self) {} } +/// Wait for a scheme to become available by polling `/scheme/{name}`. +/// Returns true if the scheme appeared within the timeout, false otherwise. +/// +/// In initfs mode, driver-manager starts before pcid and acpid. The PCI bus +/// scheme (`/scheme/pci`) is registered by pcid, which is spawned by hwd +/// (service 40). The ACPI bus scheme (`/scheme/acpi`) is registered by acpid +/// (service 41). Without waiting, enumeration fails with 0 devices and the +/// deferred retry loop (3 × 500ms) is too short. +fn wait_for_scheme(name: &str, timeout: Duration) -> bool { + let path = format!("/scheme/{}", name); + let start = Instant::now(); + let poll_interval = Duration::from_millis(100); + + while start.elapsed() < timeout { + // Use read_dir instead of Path::exists() — Redox scheme paths + // may not respond to exists()/metadata() while still being + // functional for directory enumeration. + if fs::read_dir(&path).is_ok() { + log::info!( + "scheme {} available after {}ms", + name, + start.elapsed().as_millis() + ); + return true; + } + thread::sleep(poll_interval); + } + + log::warn!( + "scheme {} not available after {}ms", + name, + timeout.as_millis() + ); + false +} + fn run_enumeration( manager: &Arc>, scheme: &DriverManagerScheme, @@ -421,6 +457,14 @@ fn main() { reset_timeline_log(); + // In initfs mode, pcid (spawned by hwd at service 40) may not have + // registered /scheme/pci yet when driver-manager starts at service 00. + // Wait for required bus schemes to appear before enumerating. + if initfs { + wait_for_scheme("pci", Duration::from_secs(30)); + wait_for_scheme("acpi", Duration::from_secs(10)); + } + if manager_config.async_probe { let handle = thread::spawn(move || { let (bound, deferred) = run_enumeration(&mgr_clone, scheme_clone.as_ref(), initfs); @@ -454,7 +498,7 @@ fn main() { idle_forever(); } - let max_retries = 3u32; + let max_retries = if initfs { 10u32 } else { 3u32 }; for retry in 1..=max_retries { if SHUTDOWN_REQUESTED.load(Ordering::SeqCst) { log::info!("driver-manager: SIGTERM received during deferred retry, shutting down"); diff --git a/local/recipes/system/firmware-loader/source/src/main.rs b/local/recipes/system/firmware-loader/source/src/main.rs index b35df00463..a6891c953f 100644 --- a/local/recipes/system/firmware-loader/source/src/main.rs +++ b/local/recipes/system/firmware-loader/source/src/main.rs @@ -212,17 +212,6 @@ fn main() { ); let firmware_dir_str = firmware_dir.to_string_lossy().into_owned(); - match manifest::generate_manifest(&firmware_dir_str) { - Ok(()) => info!( - "firmware-loader: generated firmware manifest at {}/MANIFEST.txt", - firmware_dir.display() - ), - Err(err) => warn!( - "firmware-loader: failed to generate firmware manifest for {}: {}", - firmware_dir.display(), - err - ), - } let registry = match FirmwareRegistry::new(&firmware_dir) { Ok(registry) => registry, @@ -245,6 +234,14 @@ fn main() { firmware_dir.display() ); + // Manifest generation is a host-side verification tool — skip it at runtime. + // The background thread would produce thousands of ENODEV warnings after + // setrens(0,0) makes the filesystem inaccessible, and the manifest is not + // consumed by any runtime path. + // std::thread::spawn(move || { + // let _ = manifest::generate_manifest(&firmware_dir_str); + // }); + if args.first().map(String::as_str) == Some("--probe") { println!("count={}", registry.len()); let mut keys = registry.list_keys(); diff --git a/recipes/core/base/recipe.toml b/recipes/core/base/recipe.toml index 530cc3501a..30f5664570 100644 --- a/recipes/core/base/recipe.toml +++ b/recipes/core/base/recipe.toml @@ -2,118 +2,7 @@ git = "https://gitlab.redox-os.org/redox-os/base.git" rev = "463f76b9608a896e6f6c9f63457f57f6409873c7" patches = [ - "P0-daemon-fix-init-notify-unwrap.patch", - "P0-workspace-add-bootstrap.patch", - "P0-init-continuous-scheduling.patch", - "P0-dhcpd-auto-iface.patch", - "P0-procmgr-sigchld-debug.patch", - "P0-pcid-mcfg-diagnostics.patch", - "P0-ihdgd-intel-gpu-ids.patch", - "P0-acpid-dmar-fix.patch", - # P1: acpid EC runtime and AML physmem hardening (narrow ACPI runtime patches) - "P1-acpid-ec-runtime.patch", - "P1-acpid-runtime-hardening.patch", - # Stale patches needing recreation: P1-pcid-uevent-surface, P2-boot-runtime-fixes, - # P2-hwd-misc, P2-pcid-cfg-access, P3-xhci-device-hardening, P6-cpufreqd-real-impl - "P2-i2c-gpio-ucsi-drivers.patch", - "P0-i2c-control-response-empty.patch", - "P2-ihdad-graceful-init.patch", - "P2-boot-logging.patch", - "P2-init-acpid-wiring.patch", - "P2-hwd-remove-acpid-spawn.patch", - "P2-initfs-pcid-service.patch", - "P2-misc-daemon-fixes.patch", - "P9-fix-so-pecred.patch", - "P3-inputd-keymap-bridge.patch", - # P3: ps2d consolidated — LED feedback, mouse resend, fastfail, Intellimouse2, controller init robustness, non-x86 fallback - "P7-ps2d-intellimouse2-leds-controller-init.patch", - "P3-usbhidd-hardening.patch", - "P3-init-colored-output.patch", - "P4-logd-persistent-logging.patch", - "P4-acpi-shutdown-hardening.patch", - "P4-acpi-s3-sleep.patch", - "P4-pcid-public-client-channel.patch", - "P4-pcid-config-scheme.patch", - "P4-pcid-spawner-pci-coordinate-env.patch", - "P4-initfs-usb-drm-services.patch", - "P4-initfs-release-virtio-gpu.patch", - "P4-initfs-network-services.patch", - "P4-initfs-getty-services.patch", - "P4-initfs-dbus-services.patch", - "P4-fbcond-scrollback.patch", - "P4-ucsid-estale-graceful.patch", - "P4-acpi-estale-graceful.patch", - "P4-hwd-estale-graceful.patch", - # P5-i2c-hidd-estale-retry: REDUNDANT — ESTALE retry already provided by P2 + P4-acpi-estale - "P5-acpid-dmi-endpoint.patch", - "P4-thermal-daemon.patch", - "P4-thermald-workspace.patch", - "P6-driver-main-fixes.patch", - "P6-driver-new-modules.patch", - "P9-init-scheduler-completed.patch", - "P6-init-requires-hard-dep.patch", - "P2-pcid-acpid-graceful-fd.patch", - "P5-fbbootlogd-fbcond-graceful-drm.patch", - "P7-acpid-shared-pcifd.patch", - "P6-rtcd-no-ocreat.patch", - "P6-pcid-acpid-fd-transfer.patch", - "P15-7-init-service-timeout.patch", - # P15-8-init-cycle-detection: REDUNDANT — cycle detection already included in P6-init-requires-hard-dep - "P18-1-daemon-restart.patch", - "P18-3-msi-msix-enablement.patch", - "P18-5-acpid-robustness.patch", - "P18-8-bounded-ipcd-queues.patch", - "P18-9-msi-allocation-resilience.patch", - "P19-init-startup-hardening.patch", - "P19-acpid-startup-hardening.patch", - "P20-ramfs-requires-randd.patch", - "P58-logd-requires-randd.patch", - "P21-boot-daemon-graceful-panic.patch", - "P23-rootfs-hard-dep-on-drivers.patch", - "P24-acpi-s5-derivation-shutdown-semantics.patch", - "P25-fbcond-vesa-fallback.patch", - "P26-driver-manager-initfs-conversion.patch", - "P27-fbcond-borrow-fix.patch", - "P28-init-skip-unmet-conditions.patch", - "P30-acpid-graceful-scheme-exists.patch", - "P31-xhcid-restore-interrupts.patch", - "P32-acpid-graceful-boot.patch", - "P33-vesad-graceful-boot.patch", - "P34-fbcond-fbbootlogd-env.patch", - "P35-fbcond-fbbootlogd-init.patch", - "P36-graphics-scheme-graceful-init.patch", - "P37-smolnetd-ready-after-init.patch", - "P38-vesad-eventqueue-deadlock.patch", - "P39-pci-allocate-interrupt-vector-graceful.patch", - "P40-bar-rs-graceful.patch", - "P41-common-init-graceful.patch", - "P42-inputd-graceful-fallback.patch", - "P43-dhcpd-requires-hard-dep.patch", - "P44-acpid-thermal-zones.patch", - # P54: Add missing thermal.rs module for P44 - "P54-acpid-thermal-module.patch", - # P45: Migrate e1000d and ixgbed to MSI-X via pci_allocate_interrupt_vector - "P45-net-msix-adoption.patch", - # P46: Migrate ahcid and ac97d to MSI-X via pci_allocate_interrupt_vector - "P46-storage-audio-msix.patch", - # P46b: Fix ac97d mutable borrow of pcid_handle (required by pci_allocate_interrupt_vector) - "P46b-ac97d-mutable-fix.patch", - # P47: Update thermald to read from P44 thermal zones and coretempd - "P47-thermald-backend.patch", - # P48: Add ACPI fan device discovery and status exposure - "P48-acpid-fan-support.patch", - # P49: Add IRQ affinity logging and CPU tracking to pcid - "P49-irq-affinity-logging.patch", - # P50: Add structured logging rate limiter and thermald integration - "P50-structured-logging.patch", - # P51: Add per-service log files and size-based rotation to logd - "P51-logd-rotation.patch", - # P52: Add ACPI C-state discovery and thermal-based C-state policy - "P52-acpid-cstates.patch", - # P53: Add e1000d interrupt throttling rate (ITR) coalescing - "P53-e1000d-itr-coalescing.patch", - # P55: Add JSON structured log format option to logd - "P55-logd-json-format.patch", + "redox.patch", ] [package] @@ -165,6 +54,7 @@ installs = [ "/usr/lib/drivers/usbhubd", "/usr/lib/drivers/usbscsid", "/usr/lib/drivers/vboxd", + "/usr/lib/drivers/virtio-blkd", "/usr/lib/drivers/virtio-gpud", "/usr/lib/drivers/virtio-netd", "/usr/lib/drivers/xhcid", @@ -240,9 +130,10 @@ BINS=( usbhubd ucsid usbscsid - virtio-gpud - virtio-netd - xhcid + virtio-blkd + virtio-gpud + virtio-netd + xhcid i2cd inputd ) diff --git a/recipes/core/base/source b/recipes/core/base/source index 463f76b960..cb0cd1f850 160000 --- a/recipes/core/base/source +++ b/recipes/core/base/source @@ -1 +1 @@ -Subproject commit 463f76b9608a896e6f6c9f63457f57f6409873c7 +Subproject commit cb0cd1f850394741459bde99b351e5dd6a73a041 diff --git a/recipes/core/bootloader/recipe.toml b/recipes/core/bootloader/recipe.toml index cc0fc74a9a..3d749942d7 100644 --- a/recipes/core/bootloader/recipe.toml +++ b/recipes/core/bootloader/recipe.toml @@ -1,6 +1,6 @@ [source] git = "https://gitlab.redox-os.org/redox-os/bootloader.git" -patches = ["redox.patch", "fix-uefi-alloc-panic.patch", "P0-gpt-partition-offset.patch", "P5-live-preload-cap-1gib.patch"] +patches = ["redox.patch", "fix-uefi-alloc-panic.patch", "P0-gpt-partition-offset.patch", "P5-live-preload-cap-128mib.patch", "P6-full-ramdisk-preload.patch"] [build] template = "custom" diff --git a/recipes/core/bootloader/source b/recipes/core/bootloader/source index b22a35c467..2a718991b3 160000 --- a/recipes/core/bootloader/source +++ b/recipes/core/bootloader/source @@ -1 +1 @@ -Subproject commit b22a35c467a8b95af6b856be0906fc60f81e846f +Subproject commit 2a718991b3deb343746f2dbb0ee9b3e63a4c47d8 diff --git a/recipes/core/kernel/recipe.toml b/recipes/core/kernel/recipe.toml index 8be1cda630..2957124a8d 100644 --- a/recipes/core/kernel/recipe.toml +++ b/recipes/core/kernel/recipe.toml @@ -47,6 +47,8 @@ patches = [ "../../../local/patches/kernel/P23-sys-msr-scheme.patch", # P25: Comprehensive cpuidle framework with deep C-states (C1-C7) "../../../local/patches/kernel/P25-cpuidle-deep-cstates.patch", + # P26: DebugDisplay proper scrolling — ptr::copy rows up instead of wrapping to top + "../../../local/patches/kernel/P26-debug-display-scroll.patch", ] [build] diff --git a/recipes/core/kernel/source/src/devices/graphical_debug/debug.rs b/recipes/core/kernel/source/src/devices/graphical_debug/debug.rs index 4b684c8a30..41675f2360 100644 --- a/recipes/core/kernel/source/src/devices/graphical_debug/debug.rs +++ b/recipes/core/kernel/source/src/devices/graphical_debug/debug.rs @@ -27,6 +27,9 @@ pub struct DebugDisplay { } impl DebugDisplay { + const CHAR_WIDTH: usize = 8; + const CHAR_HEIGHT: usize = 16; + pub(super) fn new( width: usize, height: usize, @@ -40,8 +43,8 @@ impl DebugDisplay { onscreen_ptr, }; - let w = display.width / 8; - let h = display.height / 16; + let w = display.width / Self::CHAR_WIDTH; + let h = display.height / Self::CHAR_HEIGHT; DebugDisplay { display, x: 0, @@ -52,11 +55,36 @@ impl DebugDisplay { } } + fn scroll_up(&mut self) { + let stride = self.display.stride; + let width = self.display.width; + let total_height = self.display.height; + let scroll_px = Self::CHAR_HEIGHT; + + unsafe { + let ptr = self.display.onscreen_ptr; + for row in 0..total_height - scroll_px { + ptr::copy( + ptr.add((row + scroll_px) * stride), + ptr.add(row * stride), + width, + ); + } + for row in total_height - scroll_px..total_height { + ptr::write_bytes(ptr.add(row * stride), 0, width); + } + } + } + pub fn write(&mut self, buf: &[u8]) { for &b in buf { if self.x >= self.w || b == b'\n' { self.x = 0; - self.y = (self.y + 1) % self.h; + self.y += 1; + if self.y >= self.h { + self.scroll_up(); + self.y = self.h - 1; + } } if b == b'\r' { @@ -64,52 +92,44 @@ impl DebugDisplay { } match (b, &self.mode) { - // Byte 0x1B starts ESC sequence (0x1B, _) => { self.mode = Mode::Esc; continue; } - // Ignore other nonprintable characters (0x00..=0x1F | 0x80..=0xFF, _) => { self.mode = Mode::Plain; continue; } - // '[' after ESC starts CSI sequence (b'[', Mode::Esc) => { self.mode = Mode::Csi; continue; } - // Capture any bytes after ESC (_, Mode::Esc) => { self.mode = Mode::Plain; continue; } - // Byte 0x40 to 0x7E ends CSI (0x40..=0x7E, Mode::Csi) => { self.mode = Mode::Plain; continue; } - // Capture any bytes after CSI (_, Mode::Csi) => { continue; } - // Allow any other bytes (_, Mode::Plain) => {} } if self.x == 0 { self.clear_row(self.y); - self.clear_row((self.y + 1) % self.h); } - self.char(self.x * 8, self.y * 16, b as char, 0xFFFFFF); + self.char(self.x * Self::CHAR_WIDTH, self.y * Self::CHAR_HEIGHT, b as char, 0xFFFFFF); self.x += 1; } } fn clear_row(&mut self, y: usize) { - for row in y * 16..(y + 1) * 16 { + for row in y * Self::CHAR_HEIGHT..(y + 1) * Self::CHAR_HEIGHT { unsafe { ptr::write_bytes( self.display.onscreen_ptr.add(row * self.display.stride), @@ -120,36 +140,28 @@ impl DebugDisplay { } } - /// Draw a character fn char(&mut self, x: usize, y: usize, character: char, color: u32) { - if x + 8 <= self.display.width && y + 16 <= self.display.height { - let phys_y = y % self.display.height; - let mut dst = unsafe { - self.display - .onscreen_ptr - .add(phys_y * self.display.stride + x) - }; + if x + Self::CHAR_WIDTH > self.display.width || y + Self::CHAR_HEIGHT > self.display.height { + return; + } + + let font_i = Self::CHAR_HEIGHT * (character as usize); + if font_i + Self::CHAR_HEIGHT > FONT.len() { + return; + } - let font_i = 16 * (character as usize); - if font_i + 16 <= FONT.len() { - for row in 0..16 { - let row_data = FONT[font_i + row]; - for col in 0..8 { - if (row_data >> (7 - col)) & 1 == 1 { unsafe { + let ptr = self.display.onscreen_ptr; + let stride = self.display.stride; + for row in 0..Self::CHAR_HEIGHT { + let row_data = FONT[font_i + row]; + let dst = ptr.add((y + row) * stride + x); + for col in 0..Self::CHAR_WIDTH { + if (row_data >> (Self::CHAR_WIDTH - 1 - col)) & 1 == 1 { *dst.add(col) = color; } } } - - let next_phys_y = (phys_y + row + 1) % self.display.height; - dst = unsafe { - self.display - .onscreen_ptr - .add(next_phys_y * self.display.stride + x) - }; - } - } } } } diff --git a/recipes/core/relibc/recipe.toml b/recipes/core/relibc/recipe.toml index b7f049f01f..38d0f22449 100644 --- a/recipes/core/relibc/recipe.toml +++ b/recipes/core/relibc/recipe.toml @@ -31,9 +31,8 @@ patches = [ # sys/types/internal.h → stdint.h → cycle # Headers needing stdint.h include it directly (signal.h, signalfd.h, eventfd.h). - # open_memstream: temporarily disabled — module file and wiring need recreation - # "P3-open-memstream-create.patch", - # "P3-stdio-open-memstream-mod.patch", + # open_memstream: single-patch implementation in stdio/mod.rs + "P3-open-memstream.patch", # F_DUPFD_CLOEXEC fallback (try CLOEXEC, fall back to DUPFD + SETFD) "P3-fcntl-dupfd-cloexec.patch", # Non-conflicting individual patches diff --git a/recipes/libs/libiconv/recipe.toml b/recipes/libs/libiconv/recipe.toml index fbb62bb311..e45018fcbe 100644 --- a/recipes/libs/libiconv/recipe.toml +++ b/recipes/libs/libiconv/recipe.toml @@ -100,10 +100,10 @@ for relative in ('configure', 'libcharset/configure'): path = Path(os.environ['COOKBOOK_SOURCE']) / relative lines = path.read_text().splitlines() for i, line in enumerate(lines): - if "macro_version='2.4.7'" in line or "macro_version='2.5.4-redox-9510'" in line: - lines[i] = "macro_version='2.6.0'" - if "macro_revision='2.4.7'" in line or "macro_revision='2.5.4-redox-9510'" in line: - lines[i] = "macro_revision='2.6.0'" + if "macro_version='2.4.7'" in line or "macro_version='2.5.4-redox-9510'" in line or "macro_version='2.6.0'" in line: + lines[i] = "macro_version='2.6.0.23-b08cb'" + if "macro_revision='2.4.7'" in line or "macro_revision='2.5.4-redox-9510'" in line or "macro_revision='2.6.0'" in line: + lines[i] = "macro_revision='2.6.0.23'" if "grep -v '^ *+' conftest.err >conftest.er1" in line: lines[i] = "test -f conftest.err && grep -v '^ *+' conftest.err > conftest.er1.tmp && mv -f conftest.er1.tmp conftest.er1 || :" if 'cat conftest.er1 >&5' in line: diff --git a/recipes/libs/libiconv/source/configure b/recipes/libs/libiconv/source/configure index ed422afa67..3e4baf6317 100755 --- a/recipes/libs/libiconv/source/configure +++ b/recipes/libs/libiconv/source/configure @@ -31490,8 +31490,8 @@ AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}" sed_quote_subst='$sed_quote_subst' double_quote_subst='$double_quote_subst' delay_variable_subst='$delay_variable_subst' -macro_version='2.6.0.23-b08cb' -macro_revision='2.6.0.23' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' diff --git a/recipes/libs/libiconv/source/libcharset/configure b/recipes/libs/libiconv/source/libcharset/configure index 96edc051c9..1bf22b0b4d 100755 --- a/recipes/libs/libiconv/source/libcharset/configure +++ b/recipes/libs/libiconv/source/libcharset/configure @@ -13903,8 +13903,8 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 sed_quote_subst='$sed_quote_subst' double_quote_subst='$double_quote_subst' delay_variable_subst='$delay_variable_subst' -macro_version='2.6.0.23-b08cb' -macro_revision='2.6.0.23' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' diff --git a/recipes/tools/gettext/source/config.h.in b/recipes/tools/gettext/source/config.h.in new file mode 100644 index 0000000000..e69de29bb2 diff --git a/recipes/tools/gettext/source/gettext-runtime/Makefile.in b/recipes/tools/gettext/source/gettext-runtime/Makefile.in index f0786a9a30..257f832bb4 100644 --- a/recipes/tools/gettext/source/gettext-runtime/Makefile.in +++ b/recipes/tools/gettext/source/gettext-runtime/Makefile.in @@ -344,11 +344,12 @@ am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/config.h.in \ $(top_srcdir)/../build-aux/missing \ $(top_srcdir)/../build-aux/mkinstalldirs ../build-aux/compile \ ../build-aux/config.guess ../build-aux/config.rpath \ - ../build-aux/config.sub ../build-aux/install-sh \ - ../build-aux/ltmain.sh ../build-aux/mdate-sh \ - ../build-aux/missing ../build-aux/mkinstalldirs \ - ../build-aux/texinfo.tex ../build-aux/ylwrap ABOUT-NLS AUTHORS \ - COPYING ChangeLog INSTALL NEWS README + ../build-aux/config.sub ../build-aux/depcomp \ + ../build-aux/install-sh ../build-aux/ltmain.sh \ + ../build-aux/mdate-sh ../build-aux/missing \ + ../build-aux/mkinstalldirs ../build-aux/texinfo.tex \ + ../build-aux/ylwrap ABOUT-NLS AUTHORS COPYING ChangeLog \ + INSTALL NEWS README DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) distdir = $(PACKAGE)-$(VERSION) top_distdir = $(distdir) diff --git a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/output.0 b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/output.0 index f9f678005f..309a267565 100644 --- a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/output.0 +++ b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/output.0 @@ -1,11 +1,11 @@ @%:@! /bin/sh @%:@ Guess values for system-dependent variables and create Makefiles. -@%:@ Generated by GNU Autoconf 2.72 for gettext-runtime 0.22.5. +@%:@ Generated by GNU Autoconf 2.73 for gettext-runtime 0.22.5. @%:@ @%:@ Report bugs to . @%:@ @%:@ -@%:@ Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation, +@%:@ Copyright (C) 1992-1996, 1998-2017, 2020-2026 Free Software Foundation, @%:@ Inc. @%:@ @%:@ @@ -22,7 +22,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in @%:@( @@ -109,7 +109,7 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi @@ -131,10 +131,13 @@ case $- in @%:@ (((( *x* ) as_opts=-x ;; * ) as_opts= ;; esac -exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +case $@%:@ in @%:@ (( + 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;; + *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;; +esac # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. -printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 +printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi # We don't want this to propagate to other subprocesses. @@ -145,7 +148,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case e in @%:@( @@ -263,22 +266,25 @@ case $- in @%:@ (((( *x* ) as_opts=-x ;; * ) as_opts= ;; esac -exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +case $@%:@ in @%:@ (( + 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;; + *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;; +esac # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed 'exec'. -printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 +printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno then : - printf "%s\n" "$0: This script requires a shell more modern than all" - printf "%s\n" "$0: the shells that I found on your system." + printf '%s\n' "$0: This script requires a shell more modern than all" + printf '%s\n' "$0: the shells that I found on your system." if test ${ZSH_VERSION+y} ; then - printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should" - printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later." + printf '%s\n' "$0: In particular, zsh $ZSH_VERSION has bugs and should" + printf '%s\n' "$0: be upgraded to zsh 4.3.4 or later." else - printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and + printf '%s\n' "$0: Please tell bug-autoconf@gnu.org and $0: bug-gettext@gnu.org about your system, including any $0: error possibly output before this message. Then install $0: a modern shell, or manually run the script under such a @@ -339,7 +345,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" @@ -348,7 +354,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_dir" | +printf '%s\n' X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -431,9 +437,9 @@ as_fn_error () as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - printf "%s\n" "$as_me: error: $2" >&2 + printf '%s\n' "$as_me: error: $2" >&2 as_fn_exit $as_status } @%:@ as_fn_error @@ -460,7 +466,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X/"$0" | +printf '%s\n' X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -506,7 +512,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || - { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + { printf '%s\n' "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall @@ -520,29 +526,6 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits exit } - -# Determine whether it's possible to make 'echo' print without a newline. -# These variables are no longer used directly by Autoconf, but are AC_SUBSTed -# for compatibility with existing Makefiles. -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in @%:@((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -# For backward compatibility with old third-party macros, we provide -# the shell variables $as_echo and $as_echo_n. New code should use -# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. -as_@&t@echo='printf %s\n' -as_@&t@echo_n='printf %s' - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -603,6 +586,7 @@ ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # Initializations. # ac_default_prefix=/usr/local +ac_clean_CONFIG_STATUS= ac_clean_files= ac_config_libobj_dir=. LIB@&t@OBJS= @@ -658,7 +642,7 @@ gt_needs= ac_func_c_list= gl_getopt_required=POSIX enable_option_checking=no -enable_year2038=no +: ${enable_year2038:=no} ac_subst_vars='gltests_LIBOBJDEPS gltests_LTLIBOBJS gltests_LIBOBJS @@ -2126,13 +2110,13 @@ am__isrc INSTALL_DATA INSTALL_SCRIPT INSTALL_PROGRAM +ECHO_T +ECHO_N +ECHO_C target_alias host_alias build_alias LIBS -ECHO_T -ECHO_N -ECHO_C DEFS mandir localedir @@ -2321,7 +2305,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -2347,7 +2331,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -2560,7 +2544,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -2576,7 +2560,7 @@ do expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -2620,9 +2604,9 @@ Try '$0 --help' for more information" *) # FIXME: should be removed in autoconf 3.0. - printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2 + printf '%s\n' "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2 + printf '%s\n' "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; @@ -2630,7 +2614,7 @@ Try '$0 --help' for more information" done if test -n "$ac_prev"; then - ac_option=--`echo $ac_prev | sed 's/_/-/g'` + ac_option=--`printf '%s\n' $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi @@ -2638,7 +2622,7 @@ if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; - *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + *) printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi @@ -2702,7 +2686,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_myself" | +printf '%s\n' X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -2920,9 +2904,9 @@ if test "$ac_init_help" = "recursive"; then case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` + ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -2959,7 +2943,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix echo && $SHELL "$ac_srcdir/configure" --help=recursive else - printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + printf '%s\n' "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done @@ -2969,9 +2953,9 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF gettext-runtime configure 0.22.5 -generated by GNU Autoconf 2.72 +generated by GNU Autoconf 2.73 -Copyright (C) 2023 Free Software Foundation, Inc. +Copyright (C) 2026 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -2995,7 +2979,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3003,7 +2987,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err @@ -3011,7 +2995,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3034,7 +3018,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3042,7 +3026,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err @@ -3050,7 +3034,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3068,7 +3052,7 @@ fi ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : @@ -3090,8 +3074,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } @%:@ ac_fn_c_check_header_compile @@ -3109,7 +3093,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3117,7 +3101,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_cxx_werror_flag" || test ! -s conftest.err @@ -3125,7 +3109,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3149,7 +3133,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3157,7 +3141,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err @@ -3168,7 +3152,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3190,7 +3174,7 @@ fi ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : @@ -3242,8 +3226,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } @%:@ ac_fn_c_check_func @@ -3260,7 +3244,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3268,7 +3252,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || test ! -s conftest.err @@ -3276,7 +3260,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3300,7 +3284,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -3308,7 +3292,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_cxx_werror_flag" || test ! -s conftest.err @@ -3319,7 +3303,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 ;; @@ -3342,7 +3326,7 @@ fi ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : @@ -3388,8 +3372,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } @%:@ ac_fn_c_check_type @@ -3407,26 +3391,26 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } then : ac_retval=0 else case e in @%:@( - e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 - printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: program exited with status $ac_status" >&5 + printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status ;; @@ -3645,7 +3629,7 @@ ac_fn_check_decl () fi as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack as_decl_name=`echo $2|sed 's/ *(.*//'` - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 printf %s "checking whether $as_decl_name is declared... " >&6; } if eval test \${$3+y} then : @@ -3685,8 +3669,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext esac fi eval ac_res=\$$3 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno ac_compile="$ac_saved_ac_compile" @@ -3699,7 +3683,7 @@ printf "%s\n" "$ac_res" >&6; } ac_fn_c_check_member () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 printf %s "checking for $2.$3... " >&6; } if eval test \${$4+y} then : @@ -3749,8 +3733,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi eval ac_res=\$$4 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } @%:@ ac_fn_c_check_member @@ -3759,7 +3743,7 @@ for ac_arg do case $ac_arg in *\'*) - ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_configure_args_raw " '$ac_arg'" done @@ -3771,7 +3755,7 @@ case $ac_configure_args_raw in ac_unsafe_z='|&;<>()$`\\"*?@<:@ '' ' # This string ends in space, tab. ac_unsafe_a="$ac_unsafe_z#~" ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g" - ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; + ac_configure_args_raw=` printf '%s\n' "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;; esac cat >config.log <<_ACEOF @@ -3779,7 +3763,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by gettext-runtime $as_me 0.22.5, which was -generated by GNU Autoconf 2.72. Invocation command line was +generated by GNU Autoconf 2.73. Invocation command line was $ $0$ac_configure_args_raw @@ -3819,7 +3803,7 @@ do */) ;; *) as_dir=$as_dir/ ;; esac - printf "%s\n" "PATH: $as_dir" + printf '%s\n' "PATH: $as_dir" done IFS=$as_save_IFS @@ -3854,7 +3838,7 @@ do | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) - ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; @@ -3883,31 +3867,22 @@ done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} -# When interrupted or exit'd, cleanup temporary files, and complete -# config.log. We remove comments because anyway the quotes in there -# would cause problems or look ugly. -# WARNING: Use '\'' to represent an apostrophe within the trap. -# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. -trap 'exit_status=$? - # Sanitize IFS. - IFS=" "" $as_nl" - # Save into config.log some information that might help in debugging. - { - echo - - printf "%s\n" "## ---------------- ## -## Cache variables. ## -## ---------------- ##" - echo - # The following way of writing the cache mishandles newlines in values, +# Dump the cache to stdout. It can be in a pipe (this is a requirement). +ac_cache_dump () +{ + # The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. ( - for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + *_cv_*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +printf '%s\n' "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( @@ -3916,67 +3891,95 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} esac ;; esac done + (set) 2>&1 | - case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) + # 'set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ - "s/'\''/'\''\\\\'\'''\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) + # 'set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) - echo +} - printf "%s\n" "## ----------------- ## +# Print debugging info to stdout. +ac_dump_debugging_info () +{ + echo + + printf '%s\n' "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + ac_cache_dump + echo + + printf '%s\n' "## ----------------- ## ## Output variables. ## ## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;; + esac + printf '%s\n' "$ac_var='$ac_val'" + done | sort + echo + + if test -n "$ac_subst_files"; then + printf '%s\n' "## ------------------- ## +## File substitutions. ## +## ------------------- ##" echo - for ac_var in $ac_subst_vars + for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;; esac - printf "%s\n" "$ac_var='\''$ac_val'\''" + printf '%s\n' "$ac_var='$ac_val'" done | sort echo + fi - if test -n "$ac_subst_files"; then - printf "%s\n" "## ------------------- ## -## File substitutions. ## -## ------------------- ##" - echo - for ac_var in $ac_subst_files - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - printf "%s\n" "$ac_var='\''$ac_val'\''" - done | sort - echo - fi - - if test -s confdefs.h; then - printf "%s\n" "## ----------- ## + if test -s confdefs.h; then + printf '%s\n' "## ----------- ## ## confdefs.h. ## ## ----------- ##" - echo - cat confdefs.h - echo - fi - test "$ac_signal" != 0 && - printf "%s\n" "$as_me: caught signal $ac_signal" - printf "%s\n" "$as_me: exit $exit_status" - } >&5 - rm -f core *.core core.conftest.* && + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + printf '%s\n' "$as_me: caught signal $ac_signal" + printf '%s\n' "$as_me: exit $exit_status" +} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. +ac_exit_trap () +{ + exit_status= + # Sanitize IFS. + IFS=" "" $as_nl" + # Save into config.log some information that might help in debugging. + ac_dump_debugging_info >&5 + eval "rm -f $ac_clean_CONFIG_STATUS core *.core core.conftest.*" && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status -' 0 +} + +trap 'ac_exit_trap $?' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done @@ -3985,21 +3988,21 @@ ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h -printf "%s\n" "/* confdefs.h */" > confdefs.h +printf '%s\n' "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. -printf "%s\n" "@%:@define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h -printf "%s\n" "@%:@define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h -printf "%s\n" "@%:@define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h -printf "%s\n" "@%:@define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h -printf "%s\n" "@%:@define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h -printf "%s\n" "@%:@define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. @@ -4021,12 +4024,12 @@ do ac_site_file=./$ac_site_file ;; esac if test -f "$ac_site_file" && test -r "$ac_site_file"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 -printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +printf '%s\n' "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ - || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + || { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See 'config.log' for more details" "$LINENO" 5; } fi @@ -4036,27 +4039,120 @@ if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 -printf "%s\n" "$as_me: loading cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +printf '%s\n' "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 -printf "%s\n" "$as_me: creating cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +printf '%s\n' "$as_me: creating cache $cache_file" >&6;} >$cache_file fi +# Test code for whether the C compiler supports C23 (global declarations) +ac_c_conftest_c23_globals=' +/* Does the compiler advertise conformance to C17 or earlier? + Although GCC 14 does not do that, even with -std=gnu23, + it is close enough, and defines __STDC_VERSION == 202000L. */ +#if !defined __STDC_VERSION__ || __STDC_VERSION__ <= 201710L +# error "Compiler advertises conformance to C17 or earlier" +#endif + +// Check alignas. +char alignas (double) c23_aligned_as_double; +char alignas (0) c23_no_special_alignment; +extern char c23_aligned_as_int; +char alignas (0) alignas (int) c23_aligned_as_int; + +// Check alignof. +enum +{ + c23_int_alignment = alignof (int), + c23_int_array_alignment = alignof (int[100]), + c23_char_alignment = alignof (char) +}; +static_assert (0 < -alignof (int), "alignof is signed"); + +int function_with_unnamed_parameter (int) { return 0; } + +void c23_noreturn (); + +/* Test parsing of string and char UTF-8 literals (including hex escapes). + The parens pacify GCC 15. */ +bool use_u8 = (!sizeof u8"\xFF") == (!u8'\''x'\''); + +bool check_that_bool_works = true | false | !nullptr; +#if !true +# error "true does not work in #if" +#endif +#if false +#elifdef __STDC_VERSION__ +#else +# error "#elifdef does not work" +#endif + +#ifndef __has_c_attribute +# error "__has_c_attribute not defined" +#endif + +#ifndef __has_include +# error "__has_include not defined" +#endif + +#define LPAREN() ( +#define FORTY_TWO(x) 42 +#define VA_OPT_TEST(r, x, ...) __VA_OPT__ (FORTY_TWO r x)) +static_assert (VA_OPT_TEST (LPAREN (), 0, <:-) == 42); + +static_assert (0b101010 == 42); +static_assert (0B101010 == 42); +static_assert (0xDEAD'\''BEEF == 3'\''735'\''928'\''559); +static_assert (0.500'\''000'\''000 == 0.5); + +enum unsignedish : unsigned int { uione = 1 }; +static_assert (0 < -uione); + +#include +constexpr nullptr_t null_pointer = nullptr; + +static typeof (1 + 1L) two () { return 2; } +static long int three () { return 3; } +' + +# Test code for whether the C compiler supports C23 (body of main). +ac_c_conftest_c23_main=' + { + label_before_declaration: + int arr[10] = {}; + if (arr[0]) + goto label_before_declaration; + if (!arr[0]) + goto label_at_end_of_block; + label_at_end_of_block: + } + ok |= !null_pointer; + ok |= two != three; +' + +# Test code for whether the C compiler supports C23 (complete). +ac_c_conftest_c23_program="${ac_c_conftest_c23_globals} + +int +main (int, char **) +{ + int ok = 0; + ${ac_c_conftest_c23_main} + return ok; +} +" + # Test code for whether the C compiler supports C89 (global declarations) ac_c_conftest_c89_globals=' -/* Does the compiler advertise C89 conformance? - Do not test the value of __STDC__, because some compilers set it to 0 - while being otherwise adequately conformant. */ -#if !defined __STDC__ -# error "Compiler does not advertise C89 conformance" -#endif +/* Do not test the value of __STDC__, because some compilers define it to 0 + or do not define it, while otherwise adequately conforming. */ #include #include @@ -4136,7 +4232,8 @@ extern void free (void *); // Check varargs macros. These examples are taken from C99 6.10.3.5. // dprintf is used instead of fprintf to avoid needing to declare -// FILE and stderr. +// FILE and stderr, and "aND" is used instead of "and" to work around +// GCC bug 40564 which is irrelevant here. #define debug(...) dprintf (2, __VA_ARGS__) #define showlist(...) puts (#__VA_ARGS__) #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) @@ -4147,7 +4244,7 @@ test_varargs_macros (void) int y = 5678; debug ("Flag"); debug ("X = %d\n", x); - showlist (The first, second, and third items.); + showlist (The first, second, aND third items.); report (x>y, "x is %d but y is %d", x, y); } @@ -4235,15 +4332,15 @@ ac_c_conftest_c99_main=' // Check restrict. if (test_restrict ("String literal") == 0) success = true; - char *restrict newvar = "Another string"; + const char *restrict newvar = "Another string"; // Check varargs. success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234); test_varargs_macros (); // Check flexible array members. - struct incomplete_array *ia = - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); + static struct incomplete_array *volatile incomplete_array_pointer; + struct incomplete_array *ia = incomplete_array_pointer; ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; @@ -4259,13 +4356,12 @@ ac_c_conftest_c99_main=' ni.number = 58; - int dynamic_array[ni.number]; - dynamic_array[0] = argv[0][0]; - dynamic_array[ni.number - 1] = 543; + // Do not test for VLAs, as some otherwise-conforming compilers lack them. + // C code should instead use __STDC_NO_VLA__; see Autoconf manual. // work around unused variable warnings ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' - || dynamic_array[ni.number - 1] != 543); + || ni.number != 58); ' # Test code for whether the C compiler supports C11 (global declarations) @@ -4436,7 +4532,7 @@ ac_aux_dir_candidates="${srcdir}/../build-aux" # $ac_aux_dir_candidates and give up. ac_missing_aux_files="" ac_first_candidate=: -printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 +printf '%s\n' "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in $ac_aux_dir_candidates @@ -4449,7 +4545,7 @@ do esac as_found=: - printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5 ac_aux_dir_found=yes ac_install_sh= for ac_aux in $ac_aux_files @@ -4460,13 +4556,13 @@ do if test x"$ac_aux" = x"install-sh" then if test -f "${as_dir}install-sh"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5 ac_install_sh="${as_dir}install-sh -c" elif test -f "${as_dir}install.sh"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5 ac_install_sh="${as_dir}install.sh -c" elif test -f "${as_dir}shtool"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5 ac_install_sh="${as_dir}shtool install -c" else ac_aux_dir_found=no @@ -4478,7 +4574,7 @@ do fi else if test -f "${as_dir}${ac_aux}"; then - printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5 else ac_aux_dir_found=no if $ac_first_candidate; then @@ -4531,38 +4627,44 @@ for ac_var in $ac_precious_vars; do eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 -printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 +printf '%s\n' "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 -printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 +printf '%s\n' "$as_me: error: '$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. - ac_old_val_w=`echo x $ac_old_val` - ac_new_val_w=`echo x $ac_new_val` + ac_old_val_w= + for ac_val in x $ac_old_val; do + ac_old_val_w="$ac_old_val_w $ac_val" + done + ac_new_val_w= + for ac_val in x $ac_new_val; do + ac_new_val_w="$ac_new_val_w $ac_val" + done if test "$ac_old_val_w" != "$ac_new_val_w"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 -printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 +printf '%s\n' "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 -printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 +printf '%s\n' "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 -printf "%s\n" "$as_me: former value: '$ac_old_val'" >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 -printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 +printf '%s\n' "$as_me: former value: '$ac_old_val'" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 +printf '%s\n' "$as_me: current value: '$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in - *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=$ac_var=`printf '%s\n' "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in @@ -4572,10 +4674,10 @@ printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} fi done if $ac_cache_corrupted; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 -printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +printf '%s\n' "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file' and start over" "$LINENO" 5 fi @@ -4583,6 +4685,23 @@ fi ## Main body of script. ## ## -------------------- ## + +# Determine whether it's possible to make 'echo' print without a newline. +# These variables are no longer used directly by Autoconf, but are AC_SUBSTed +# for compatibility with existing Makefiles. +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in @%:@((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -4610,7 +4729,7 @@ am__api_version='1.18' # OS/2's system install, which has a completely different semantic # ./install, which can be erroneously created by make from ./install.sh. # Reject install programs that cannot install multiple files. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 printf %s "checking for a BSD-compatible install... " >&6; } if test -z "$INSTALL"; then if test ${ac_cv_path_install+y} @@ -4633,8 +4752,8 @@ case $as_dir in @%:@(( ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ /usr/ucb/* ) ;; *) - # OSF1 and SCO ODT 3.0 have their own names for install. - # Don't use installbsd from OSF since it installs stuff as root + # OSF/1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF/1 since it installs stuff as root # by default. for ac_prog in ginstall scoinst install; do for ac_exec_ext in '' $ac_executable_extensions; do @@ -4684,8 +4803,8 @@ fi INSTALL=$ac_install_sh fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 -printf "%s\n" "$INSTALL" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +printf '%s\n' "$INSTALL" >&6; } # Use test -z because SunOS4 sh mishandles braces in ${var-val}. # It thinks the first close brace ends the variable substitution. @@ -4695,7 +4814,7 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether sleep supports fractional seconds" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether sleep supports fractional seconds" >&5 printf %s "checking whether sleep supports fractional seconds... " >&6; } if test ${am_cv_sleep_fractional_seconds+y} then : @@ -4711,10 +4830,10 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_sleep_fractional_seconds" >&5 -printf "%s\n" "$am_cv_sleep_fractional_seconds" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_sleep_fractional_seconds" >&5 +printf '%s\n' "$am_cv_sleep_fractional_seconds" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking filesystem timestamp resolution" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking filesystem timestamp resolution" >&5 printf %s "checking filesystem timestamp resolution... " >&6; } if test ${am_cv_filesystem_timestamp_resolution+y} then : @@ -4766,9 +4885,9 @@ if ( # if, for instance, CONFIG_SHELL is bash and it inherits a # broken ls alias from the environment. This has actually # happened. Such a system could not be considered "sane". - printf "%s\n" ""Bad output from ls -t: \"`ls -t conftest.ts[12]`\""" >&5 - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + printf '%s\n' ""Bad output from ls -t: \"`ls -t conftest.ts[12]`\""" >&5 + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "ls -t produces unexpected output. Make sure there is not a broken ls alias in your environment. See 'config.log' for more details" "$LINENO" 5; } @@ -4849,12 +4968,12 @@ rm -f conftest.ts? ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_filesystem_timestamp_resolution" >&5 -printf "%s\n" "$am_cv_filesystem_timestamp_resolution" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_filesystem_timestamp_resolution" >&5 +printf '%s\n' "$am_cv_filesystem_timestamp_resolution" >&6; } # This check should not be cached, as it may vary across builds of # different projects. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 printf %s "checking whether build environment is sane... " >&6; } # Reject unsafe characters in $srcdir or the absolute working directory # name. Accept space and tab only in the latter. @@ -4862,14 +4981,14 @@ am_lf=' ' case `pwd` in *[\\\"\#\$\&\'\`$am_lf]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; esac case $srcdir in *[\\\"\#\$\&\'\`$am_lf\ \ ]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; esac @@ -4899,8 +5018,8 @@ for am_try in 1 2; do am_has_slept=yes done -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_build_env_is_sane" >&5 -printf "%s\n" "$am_build_env_is_sane" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_build_env_is_sane" >&5 +printf '%s\n' "$am_build_env_is_sane" >&6; } if test "$am_build_env_is_sane" = no; then as_fn_error $? "newly created file is older than distributed files! Check your system clock" "$LINENO" 5 @@ -4929,7 +5048,7 @@ test "$program_suffix" != NONE && # Double any \ or $. # By default was 's,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' -program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` +program_transform_name=`printf '%s\n' "$program_transform_name" | sed "$ac_script"` # Expand $ac_aux_dir to an absolute path. @@ -4944,8 +5063,8 @@ if eval "$MISSING --is-lightweight"; then am_missing_run="$MISSING " else am_missing_run= - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 -printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 +printf '%s\n' "$as_me: WARNING: 'missing' script is too old or missing" >&2;} fi if test x"${install_sh+set}" != xset; then @@ -4965,7 +5084,7 @@ if test "$cross_compiling" != no; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : @@ -4986,7 +5105,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4998,11 +5117,11 @@ esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 -printf "%s\n" "$STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +printf '%s\n' "$STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5011,7 +5130,7 @@ if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : @@ -5032,7 +5151,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5044,11 +5163,11 @@ esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 -printf "%s\n" "$ac_ct_STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +printf '%s\n' "$ac_ct_STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then @@ -5056,8 +5175,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP @@ -5070,7 +5189,7 @@ fi INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5 printf %s "checking for a race-free mkdir -p... " >&6; } if test -z "$MKDIR_P"; then if test ${ac_cv_path_mkdir+y} @@ -5113,14 +5232,14 @@ fi MKDIR_P='mkdir -p' fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 -printf "%s\n" "$MKDIR_P" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 +printf '%s\n' "$MKDIR_P" >&6; } -for ac_prog in gawk mawk nawk awk +for ac_prog in gawk mawk nawk awk 'busybox awk' do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AWK+y} then : @@ -5141,7 +5260,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5153,21 +5272,21 @@ esac fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 -printf "%s\n" "$AWK" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +printf '%s\n' "$AWK" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test -n "$AWK" && break done -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } set x ${MAKE-make} -ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +ac_make=`printf '%s\n' "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval test \${ac_cv_prog_make_${ac_make}_set+y} then : printf %s "(cached) " >&6 @@ -5175,7 +5294,7 @@ else case e in @%:@( e) cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: - @echo '@@@%%%=$(MAKE)=@@@%%%' + @printf '%s\n' '@@@%%%=$(MAKE)=@@@%%%' _ACEOF # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. case `${MAKE-make} -f conftest.make 2>/dev/null` in @@ -5188,12 +5307,12 @@ rm -f conftest.make ;; esac fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } SET_MAKE= else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } SET_MAKE="MAKE=${MAKE-make}" fi @@ -5214,13 +5333,13 @@ then : fi am_make=${MAKE-make} -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5 printf %s "checking whether $am_make supports nested variables... " >&6; } if test ${am_cv_make_support_nested_variables+y} then : printf %s "(cached) " >&6 else case e in @%:@( - e) if printf "%s\n" 'TRUE=$(BAR$(V)) + e) if printf '%s\n' 'TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 @@ -5233,8 +5352,8 @@ else fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 -printf "%s\n" "$am_cv_make_support_nested_variables" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 +printf '%s\n' "$am_cv_make_support_nested_variables" >&6; } AM_BACKSLASH='\' am__rm_f_notfound= @@ -5247,7 +5366,7 @@ esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking xargs -n works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking xargs -n works" >&5 printf %s "checking xargs -n works... " >&6; } if test ${am_cv_xargs_n_works+y} then : @@ -5263,8 +5382,8 @@ esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_xargs_n_works" >&5 -printf "%s\n" "$am_cv_xargs_n_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_xargs_n_works" >&5 +printf '%s\n' "$am_cv_xargs_n_works" >&6; } if test "$am_cv_xargs_n_works" = yes then : am__xargs_n='xargs -n' @@ -5299,10 +5418,10 @@ fi VERSION='0.22.5' -printf "%s\n" "@%:@define PACKAGE \"$PACKAGE\"" >>confdefs.h +printf '%s\n' "@%:@define PACKAGE \"$PACKAGE\"" >>confdefs.h -printf "%s\n" "@%:@define VERSION \"$VERSION\"" >>confdefs.h +printf '%s\n' "@%:@define VERSION \"$VERSION\"" >>confdefs.h # Some tools Automake needs. @@ -5348,34 +5467,34 @@ _am_tools='gnutar plaintar pax cpio none' # (that is, avoid stderr redirection). am_uid=`id -u || echo unknown` am_gid=`id -g || echo unknown` - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether UID '$am_uid' is supported by ustar format" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether UID '$am_uid' is supported by ustar format" >&5 printf %s "checking whether UID '$am_uid' is supported by ustar format... " >&6; } if test x$am_uid = xunknown; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: ancient id detected; assuming current UID is ok, but dist-ustar might not work" >&5 -printf "%s\n" "$as_me: WARNING: ancient id detected; assuming current UID is ok, but dist-ustar might not work" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: ancient id detected; assuming current UID is ok, but dist-ustar might not work" >&5 +printf '%s\n' "$as_me: WARNING: ancient id detected; assuming current UID is ok, but dist-ustar might not work" >&2;} elif test $am_uid -le $am_max_uid; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } _am_tools=none fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether GID '$am_gid' is supported by ustar format" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether GID '$am_gid' is supported by ustar format" >&5 printf %s "checking whether GID '$am_gid' is supported by ustar format... " >&6; } if test x$gm_gid = xunknown; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: ancient id detected; assuming current GID is ok, but dist-ustar might not work" >&5 -printf "%s\n" "$as_me: WARNING: ancient id detected; assuming current GID is ok, but dist-ustar might not work" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: ancient id detected; assuming current GID is ok, but dist-ustar might not work" >&5 +printf '%s\n' "$as_me: WARNING: ancient id detected; assuming current GID is ok, but dist-ustar might not work" >&2;} elif test $am_gid -le $am_max_gid; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } _am_tools=none fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to create a ustar tar archive" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to create a ustar tar archive" >&5 printf %s "checking how to create a ustar tar archive... " >&6; } # Go ahead even if we have the value already cached. We do so because we @@ -5459,8 +5578,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_tar_ustar" >&5 -printf "%s\n" "$am_cv_prog_tar_ustar" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_tar_ustar" >&5 +printf '%s\n' "$am_cv_prog_tar_ustar" >&6; } @@ -5499,6 +5618,9 @@ test "$docdir" != '${datarootdir}/doc/${PACKAGE_TARNAME}' || docdir='${datarootd + + + ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -5507,7 +5629,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -5528,7 +5650,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5540,11 +5662,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5553,7 +5675,7 @@ if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : @@ -5574,7 +5696,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5586,11 +5708,11 @@ esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -printf "%s\n" "$ac_ct_CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CC" = x; then @@ -5598,8 +5720,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC @@ -5612,7 +5734,7 @@ if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -5633,7 +5755,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5645,11 +5767,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5658,7 +5780,7 @@ fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -5684,7 +5806,7 @@ do continue fi ac_cv_prog_CC="cc" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5708,11 +5830,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5723,7 +5845,7 @@ if test -z "$CC"; then do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -5744,7 +5866,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5756,11 +5878,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5773,7 +5895,7 @@ if test -z "$CC"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : @@ -5794,7 +5916,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5806,11 +5928,11 @@ esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -printf "%s\n" "$ac_ct_CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5822,8 +5944,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC @@ -5835,7 +5957,7 @@ if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args. set dummy ${ac_tool_prefix}clang; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : @@ -5856,7 +5978,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}clang" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5868,11 +5990,11 @@ esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -printf "%s\n" "$CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +printf '%s\n' "$CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -5881,7 +6003,7 @@ if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "clang", so it can be a program name with args. set dummy clang; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : @@ -5902,7 +6024,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="clang" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5914,11 +6036,11 @@ esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -printf "%s\n" "$ac_ct_CC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +printf '%s\n' "$ac_ct_CC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_CC" = x; then @@ -5926,8 +6048,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC @@ -5939,13 +6061,13 @@ fi fi -test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +test -z "$CC" && { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See 'config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. -printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion -version; do @@ -5955,7 +6077,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then @@ -5965,7 +6087,7 @@ printf "%s\n" "$ac_try_echo"; } >&5 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done @@ -5985,9 +6107,9 @@ ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 printf %s "checking whether the C compiler works... " >&6; } -ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +ac_link_default=`printf '%s\n' "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" @@ -6008,10 +6130,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'. @@ -6052,29 +6174,29 @@ esac fi if test -z "$ac_file" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } -printf "%s\n" "$as_me: failed program was:" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } +printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See 'config.log' for more details" "$LINENO" 5; } else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } ;; + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 printf %s "checking for C compiler default output file name... " >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 -printf "%s\n" "$ac_file" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +printf '%s\n' "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 printf %s "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in @@ -6082,10 +6204,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : # If both 'conftest.exe' and 'conftest' are 'present' (well, observable) @@ -6102,15 +6224,15 @@ for ac_file in conftest.exe conftest conftest.*; do esac done else case e in @%:@( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See 'config.log' for more details" "$LINENO" 5; } ;; esac fi rm -f conftest conftest$ac_cv_exeext -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 -printf "%s\n" "$ac_cv_exeext" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +printf '%s\n' "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext @@ -6133,7 +6255,7 @@ _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 printf %s "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" @@ -6142,10 +6264,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in @@ -6153,31 +6275,31 @@ printf "%s\n" "$ac_try_echo"; } >&5 *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "cannot run C compiled programs. If you meant to cross compile, use '--host'. See 'config.log' for more details" "$LINENO" 5; } fi fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 -printf "%s\n" "$cross_compiling" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +printf '%s\n' "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext \ conftest.o conftest.obj conftest.out ac_clean_files=$ac_clean_files_save -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 printf %s "checking for suffix of object files... " >&6; } if test ${ac_cv_objext+y} then : @@ -6201,10 +6323,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 +printf '%s\n' "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : for ac_file in conftest.o conftest.obj conftest.*; do @@ -6216,11 +6338,11 @@ then : esac done else case e in @%:@( - e) printf "%s\n" "$as_me: failed program was:" >&5 + e) printf '%s\n' "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} +{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -6228,11 +6350,11 @@ fi rm -f conftest.$ac_cv_objext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 -printf "%s\n" "$ac_cv_objext" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +printf '%s\n' "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5 printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : @@ -6264,8 +6386,8 @@ ac_cv_c_compiler_gnu=$ac_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 -printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_c_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_c_compiler_gnu if test $ac_compiler_gnu = yes; then @@ -6275,7 +6397,7 @@ else fi ac_test_CFLAGS=${CFLAGS+y} ac_save_CFLAGS=$CFLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : @@ -6343,8 +6465,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 -printf "%s\n" "$ac_cv_prog_cc_g" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +printf '%s\n' "$ac_cv_prog_cc_g" >&6; } if test $ac_test_CFLAGS; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then @@ -6363,7 +6485,56 @@ fi ac_prog_cc_stdc=no if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C23 features" >&5 +printf %s "checking for $CC option to enable C23 features... " >&6; } +if test ${ac_cv_prog_cc_c23+y} +then : + printf %s "(cached) " >&6 +else case e in @%:@( + e) ac_cv_prog_cc_c23=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c23_program +_ACEOF +for ac_arg in '' -std=gnu23 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c23=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c23" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC ;; +esac +fi + +if test "x$ac_cv_prog_cc_c23" = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } +else case e in @%:@( + e) if test "x$ac_cv_prog_cc_c23" = x +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } +else case e in @%:@( + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c23" >&5 +printf '%s\n' "$ac_cv_prog_cc_c23" >&6; } + CC="$CC $ac_cv_prog_cc_c23" ;; +esac +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c23 + ac_prog_cc_stdc=c23 ;; +esac +fi +fi +if test x$ac_prog_cc_stdc = xno +then : + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5 printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : @@ -6375,7 +6546,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_c_conftest_c11_program _ACEOF -for ac_arg in '' -std=gnu11 +for ac_arg in '' -std=gnu11 -std:c11 do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO" @@ -6392,16 +6563,16 @@ fi if test "x$ac_cv_prog_cc_c11" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in @%:@( e) if test "x$ac_cv_prog_cc_c11" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 -printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 +printf '%s\n' "$ac_cv_prog_cc_c11" >&6; } CC="$CC $ac_cv_prog_cc_c11" ;; esac fi @@ -6412,7 +6583,7 @@ fi fi if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5 printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : @@ -6441,16 +6612,16 @@ fi if test "x$ac_cv_prog_cc_c99" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in @%:@( e) if test "x$ac_cv_prog_cc_c99" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 -printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +printf '%s\n' "$ac_cv_prog_cc_c99" >&6; } CC="$CC $ac_cv_prog_cc_c99" ;; esac fi @@ -6461,7 +6632,7 @@ fi fi if test x$ac_prog_cc_stdc = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5 printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : @@ -6490,16 +6661,16 @@ fi if test "x$ac_cv_prog_cc_c89" = xno then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -printf "%s\n" "unsupported" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf '%s\n' "unsupported" >&6; } else case e in @%:@( e) if test "x$ac_cv_prog_cc_c89" = x then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -printf "%s\n" "none needed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf '%s\n' "none needed" >&6; } else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +printf '%s\n' "$ac_cv_prog_cc_c89" >&6; } CC="$CC $ac_cv_prog_cc_c89" ;; esac fi @@ -6521,7 +6692,7 @@ ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5 printf %s "checking whether $CC understands -c and -o together... " >&6; } if test ${am_cv_prog_cc_c_o+y} then : @@ -6563,8 +6734,8 @@ _ACEOF unset am_i ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 -printf "%s\n" "$am_cv_prog_cc_c_o" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 +printf '%s\n' "$am_cv_prog_cc_c_o" >&6; } if test "$am_cv_prog_cc_c_o" != yes; then # Losing compiler, so override with the script. # FIXME: It is wrong to rewrite CC. @@ -6581,7 +6752,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler is clang" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler is clang" >&5 printf %s "checking whether the compiler is clang... " >&6; } if test ${gl_cv_compiler_clang+y} then : @@ -6614,11 +6785,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_compiler_clang" >&5 -printf "%s\n" "$gl_cv_compiler_clang" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_compiler_clang" >&5 +printf '%s\n' "$gl_cv_compiler_clang" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for compiler option needed when checking for declarations" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for compiler option needed when checking for declarations" >&5 printf %s "checking for compiler option needed when checking for declarations... " >&6; } if test ${gl_cv_compiler_check_decl_option+y} then : @@ -6653,8 +6824,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_compiler_check_decl_option" >&5 -printf "%s\n" "$gl_cv_compiler_check_decl_option" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_compiler_check_decl_option" >&5 +printf '%s\n' "$gl_cv_compiler_check_decl_option" >&6; } if test "x$gl_cv_compiler_check_decl_option" != xnone; then ac_compile_for_check_decl="$ac_compile $gl_cv_compiler_check_decl_option" else @@ -6665,7 +6836,7 @@ DEPDIR="${am__leading_dot}deps" ac_config_commands="$ac_config_commands depfiles" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5 printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; } cat > confinc.mk << 'END' am__doit: @@ -6702,8 +6873,8 @@ esac fi done rm -f confinc.* confmf.* -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5 -printf "%s\n" "${_am_result}" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5 +printf '%s\n' "${_am_result}" >&6; } @%:@ Check whether --enable-dependency-tracking was given. if test ${enable_dependency_tracking+y} @@ -6728,7 +6899,7 @@ fi depcc="$CC" am_compiler_list= -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CC_dependencies_compiler_type+y} then : @@ -6841,8 +7012,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 -printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +printf '%s\n' "$am_cv_CC_dependencies_compiler_type" >&6; } CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type if @@ -6859,7 +7030,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use Java" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use Java" >&5 printf %s "checking whether to use Java... " >&6; } @%:@ Check whether --enable-java was given. if test ${enable_java+y} @@ -6870,8 +7041,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHOICE" >&5 -printf "%s\n" "$JAVA_CHOICE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHOICE" >&5 +printf '%s\n' "$JAVA_CHOICE" >&6; } @@ -6880,7 +7051,7 @@ ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 printf %s "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then @@ -6951,8 +7122,8 @@ fi else ac_cv_prog_CPP=$CPP fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -printf "%s\n" "$CPP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +printf '%s\n' "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do @@ -7000,8 +7171,8 @@ if $ac_preproc_ok then : else case e in @%:@( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -7014,7 +7185,7 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $ ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep -e" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for egrep -e" >&5 printf %s "checking for egrep -e... " >&6; } if test ${ac_cv_path_EGREP_TRADITIONAL+y} then : @@ -7051,7 +7222,7 @@ case `"$ac_path_EGREP_TRADITIONAL" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl" + printf '%s\n' 'EGREP_TRADITIONAL' >> "conftest.nl" "$ac_path_EGREP_TRADITIONAL" -E 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -7113,7 +7284,7 @@ case `"$ac_path_EGREP_TRADITIONAL" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl" + printf '%s\n' 'EGREP_TRADITIONAL' >> "conftest.nl" "$ac_path_EGREP_TRADITIONAL" 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -7144,8 +7315,8 @@ esac fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP_TRADITIONAL" >&5 -printf "%s\n" "$ac_cv_path_EGREP_TRADITIONAL" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP_TRADITIONAL" >&5 +printf '%s\n' "$ac_cv_path_EGREP_TRADITIONAL" >&6; } EGREP_TRADITIONAL=$ac_cv_path_EGREP_TRADITIONAL if test "$JAVA_CHOICE" != no @@ -7206,7 +7377,7 @@ rm -rf conftest* echo } fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Java compiler" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for Java compiler" >&5 printf %s "checking for Java compiler... " >&6; } case "$source_version" in 1.*) source_version=`echo "$source_version" | sed -e 's/^1\.//'` ;; @@ -7313,7 +7484,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_HAVE_JAVAC_IN_PATH="yes" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7409,8 +7580,8 @@ fi else ac_result="no" fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_result" >&5 -printf "%s\n" "$ac_result" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_result" >&5 +printf '%s\n' "$ac_result" >&6; } @@ -7419,7 +7590,7 @@ printf "%s\n" "$ac_result" >&6; } # Extract the first word of "jar", so it can be a program name with args. set dummy jar; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_JAR+y} then : @@ -7440,7 +7611,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_JAR="jar" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7452,11 +7623,11 @@ esac fi JAR=$ac_cv_prog_JAR if test -n "$JAR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 -printf "%s\n" "$JAR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAR" >&5 +printf '%s\n' "$JAR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7484,7 +7655,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for preferred C# implementation" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for preferred C# implementation" >&5 printf %s "checking for preferred C# implementation... " >&6; } @%:@ Check whether --enable-csharp was given. if test ${enable_csharp+y} @@ -7496,19 +7667,19 @@ esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CSHARP_CHOICE" >&5 -printf "%s\n" "$CSHARP_CHOICE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CSHARP_CHOICE" >&5 +printf '%s\n' "$CSHARP_CHOICE" >&6; } case "$CSHARP_CHOICE" in mono) -printf "%s\n" "@%:@define CSHARP_CHOICE_MONO 1" >>confdefs.h +printf '%s\n' "@%:@define CSHARP_CHOICE_MONO 1" >>confdefs.h ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C# compiler" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C# compiler" >&5 printf %s "checking for C# compiler... " >&6; } HAVE_CSHARPCOMP=1 # Extract the first word of "mcs", so it can be a program name with args. @@ -7533,7 +7704,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_HAVE_MCS_IN_PATH="yes" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7573,7 +7744,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_HAVE_CSC_IN_PATH="yes" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7618,8 +7789,8 @@ fi ;; esac done - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_result" >&5 -printf "%s\n" "$ac_result" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_result" >&5 +printf '%s\n' "$ac_result" >&6; } if test -z "${CSHARPCOMPFLAGS+set}"; then @@ -7640,7 +7811,7 @@ fi $SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 printf %s "checking build system type... " >&6; } if test ${ac_cv_build+y} then : @@ -7656,8 +7827,8 @@ ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 -printf "%s\n" "$ac_cv_build" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +printf '%s\n' "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; @@ -7673,10 +7844,10 @@ shift; shift # except with old shells: build_os=$* IFS=$ac_save_IFS -case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac +case $build_os in *\ *) build_os=`printf '%s\n' "$build_os" | sed 's/ /-/g'`;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 printf %s "checking host system type... " >&6; } if test ${ac_cv_host+y} then : @@ -7691,8 +7862,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 -printf "%s\n" "$ac_cv_host" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +printf '%s\n' "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; @@ -7708,7 +7879,7 @@ shift; shift # except with old shells: host_os=$* IFS=$ac_save_IFS -case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac +case $host_os in *\ *) host_os=`printf '%s\n' "$host_os" | sed 's/ /-/g'`;; esac @@ -7718,7 +7889,7 @@ case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Minix Amsterdam compiler" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for Minix Amsterdam compiler" >&5 printf %s "checking for Minix Amsterdam compiler... " >&6; } if test ${gl_cv_c_amsterdam_compiler+y} then : @@ -7746,8 +7917,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_amsterdam_compiler" >&5 -printf "%s\n" "$gl_cv_c_amsterdam_compiler" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_amsterdam_compiler" >&5 +printf '%s\n' "$gl_cv_c_amsterdam_compiler" >&6; } if test $gl_cv_c_amsterdam_compiler = yes; then if test -z "$AR"; then @@ -7763,7 +7934,7 @@ printf "%s\n" "$gl_cv_c_amsterdam_compiler" >&6; } if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. set dummy ${ac_tool_prefix}ar; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AR+y} then : @@ -7784,7 +7955,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AR="${ac_tool_prefix}ar" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7796,11 +7967,11 @@ esac fi AR=$ac_cv_prog_AR if test -n "$AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 -printf "%s\n" "$AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +printf '%s\n' "$AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7809,7 +7980,7 @@ if test -z "$ac_cv_prog_AR"; then ac_ct_AR=$AR # Extract the first word of "ar", so it can be a program name with args. set dummy ar; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_AR+y} then : @@ -7830,7 +8001,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AR="ar" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7842,11 +8013,11 @@ esac fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 -printf "%s\n" "$ac_ct_AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +printf '%s\n' "$ac_ct_AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_AR" = x; then @@ -7854,8 +8025,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR @@ -7877,7 +8048,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. set dummy ${ac_tool_prefix}ranlib; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_RANLIB+y} then : @@ -7898,7 +8069,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7910,11 +8081,11 @@ esac fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 -printf "%s\n" "$RANLIB" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +printf '%s\n' "$RANLIB" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -7923,7 +8094,7 @@ if test -z "$ac_cv_prog_RANLIB"; then ac_ct_RANLIB=$RANLIB # Extract the first word of "ranlib", so it can be a program name with args. set dummy ranlib; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_RANLIB+y} then : @@ -7944,7 +8115,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_RANLIB="ranlib" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -7956,11 +8127,11 @@ esac fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 -printf "%s\n" "$ac_ct_RANLIB" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +printf '%s\n' "$ac_ct_RANLIB" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_RANLIB" = x; then @@ -7968,8 +8139,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RANLIB=$ac_ct_RANLIB @@ -7993,7 +8164,7 @@ do if test $ac_cache; then ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default" if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then - printf "%s\n" "#define $ac_item 1" >> confdefs.h + printf '%s\n' "#define $ac_item 1" >> confdefs.h fi ac_header= ac_cache= elif test $ac_header; then @@ -8013,7 +8184,7 @@ done if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes then : -printf "%s\n" "@%:@define STDC_HEADERS 1" >>confdefs.h +printf '%s\n' "@%:@define STDC_HEADERS 1" >>confdefs.h fi @@ -8022,7 +8193,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5 printf %s "checking whether it is safe to define __EXTENSIONS__... " >&6; } if test ${ac_cv_safe_to_define___extensions__+y} then : @@ -8051,10 +8222,10 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5 -printf "%s\n" "$ac_cv_safe_to_define___extensions__" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5 +printf '%s\n' "$ac_cv_safe_to_define___extensions__" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether _XOPEN_SOURCE should be defined" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether _XOPEN_SOURCE should be defined" >&5 printf %s "checking whether _XOPEN_SOURCE should be defined... " >&6; } if test ${ac_cv_should_define__xopen_source+y} then : @@ -8105,49 +8276,51 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_should_define__xopen_source" >&5 -printf "%s\n" "$ac_cv_should_define__xopen_source" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_should_define__xopen_source" >&5 +printf '%s\n' "$ac_cv_should_define__xopen_source" >&6; } - printf "%s\n" "@%:@define _ALL_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _ALL_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _DARWIN_C_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _COSMO_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _GNU_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _DARWIN_C_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _HPUX_ALT_XOPEN_SOCKET_API 1" >>confdefs.h + printf '%s\n' "@%:@define _GNU_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _NETBSD_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _HPUX_ALT_XOPEN_SOCKET_API 1" >>confdefs.h - printf "%s\n" "@%:@define _OPENBSD_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _NETBSD_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h + printf '%s\n' "@%:@define _OPENBSD_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_BFP_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_DFP_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_BFP_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_DFP_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_IEC_60559_TYPES_EXT__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_LIB_EXT2__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_IEC_60559_TYPES_EXT__ 1" >>confdefs.h - printf "%s\n" "@%:@define __STDC_WANT_MATH_SPEC_FUNCS__ 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_LIB_EXT2__ 1" >>confdefs.h - printf "%s\n" "@%:@define _TANDEM_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define __STDC_WANT_MATH_SPEC_FUNCS__ 1" >>confdefs.h + + printf '%s\n' "@%:@define _TANDEM_SOURCE 1" >>confdefs.h if test $ac_cv_header_minix_config_h = yes then : MINIX=yes - printf "%s\n" "@%:@define _MINIX 1" >>confdefs.h + printf '%s\n' "@%:@define _MINIX 1" >>confdefs.h - printf "%s\n" "@%:@define _POSIX_SOURCE 1" >>confdefs.h + printf '%s\n' "@%:@define _POSIX_SOURCE 1" >>confdefs.h - printf "%s\n" "@%:@define _POSIX_1_SOURCE 2" >>confdefs.h + printf '%s\n' "@%:@define _POSIX_1_SOURCE 2" >>confdefs.h else case e in @%:@( e) MINIX= ;; @@ -8155,12 +8328,12 @@ esac fi if test $ac_cv_safe_to_define___extensions__ = yes then : - printf "%s\n" "@%:@define __EXTENSIONS__ 1" >>confdefs.h + printf '%s\n' "@%:@define __EXTENSIONS__ 1" >>confdefs.h fi if test $ac_cv_should_define__xopen_source = yes then : - printf "%s\n" "@%:@define _XOPEN_SOURCE 500" >>confdefs.h + printf '%s\n' "@%:@define _XOPEN_SOURCE 500" >>confdefs.h fi @@ -8171,13 +8344,13 @@ fi case "$host_os" in openbsd*) -printf "%s\n" "@%:@define _ISOC11_SOURCE 1" >>confdefs.h +printf '%s\n' "@%:@define _ISOC11_SOURCE 1" >>confdefs.h ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use C++" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use C++" >&5 printf %s "checking whether to use C++... " >&6; } @%:@ Check whether --enable-c++ was given. if test ${enable_c__+y} @@ -8188,8 +8361,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX_CHOICE" >&5 -printf "%s\n" "$CXX_CHOICE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXX_CHOICE" >&5 +printf '%s\n' "$CXX_CHOICE" >&6; } @@ -8208,7 +8381,7 @@ printf "%s\n" "$CXX_CHOICE" >&6; } do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CXX+y} then : @@ -8229,7 +8402,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8241,11 +8414,11 @@ esac fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -printf "%s\n" "$CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf '%s\n' "$CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -8258,7 +8431,7 @@ if test -z "$CXX"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CXX+y} then : @@ -8279,7 +8452,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8291,11 +8464,11 @@ esac fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -printf "%s\n" "$ac_ct_CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +printf '%s\n' "$ac_ct_CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -8307,8 +8480,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CXX=$ac_ct_CXX @@ -8318,7 +8491,7 @@ fi fi fi if test "$CXX" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5 printf %s "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -8332,7 +8505,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then gl_cv_prog_ansicxx_works=yes if (./conftest; exit) 2>/dev/null; then @@ -8350,12 +8523,12 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_works" >&5 -printf "%s\n" "$gl_cv_prog_ansicxx_works" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_works" >&5 +printf '%s\n' "$gl_cv_prog_ansicxx_works" >&6; } if test $gl_cv_prog_ansicxx_works = no; then CXX=no else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports namespaces" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports namespaces" >&5 printf %s "checking whether the C++ compiler supports namespaces... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -8372,7 +8545,7 @@ EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then gl_cv_prog_ansicxx_namespaces=yes else @@ -8385,8 +8558,8 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_namespaces" >&5 -printf "%s\n" "$gl_cv_prog_ansicxx_namespaces" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_namespaces" >&5 +printf '%s\n' "$gl_cv_prog_ansicxx_namespaces" >&6; } if test $gl_cv_prog_ansicxx_namespaces = no; then CXX=no fi @@ -8408,7 +8581,7 @@ fi depcc="$CXX" am_compiler_list= -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CXX_dependencies_compiler_type+y} then : @@ -8521,8 +8694,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 -printf "%s\n" "$am_cv_CXX_dependencies_compiler_type" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +printf '%s\n' "$am_cv_CXX_dependencies_compiler_type" >&6; } CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type if @@ -8542,7 +8715,7 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 printf %s "checking whether the compiler supports GNU C++... " >&6; } if test ${ac_cv_cxx_compiler_gnu+y} then : @@ -8574,8 +8747,8 @@ ac_cv_cxx_compiler_gnu=$ac_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_cxx_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if test $ac_compiler_gnu = yes; then @@ -8585,7 +8758,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu fi ac_test_CXXFLAGS=${CXXFLAGS+y} ac_save_CXXFLAGS=$CXXFLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 printf %s "checking whether $CXX accepts -g... " >&6; } if test ${ac_cv_prog_cxx_g+y} then : @@ -8653,8 +8826,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -printf "%s\n" "$ac_cv_prog_cxx_g" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +printf '%s\n' "$ac_cv_prog_cxx_g" >&6; } if test $ac_test_CXXFLAGS; then CXXFLAGS=$ac_save_CXXFLAGS elif test $ac_cv_prog_cxx_g = yes; then @@ -8696,18 +8869,18 @@ then : fi if test "$enable_largefile,$enable_year2038" != no,no then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable large file support" >&5 -printf %s "checking for $CC option to enable large file support... " >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support large files" >&5 +printf %s "checking for $CC option to support large files... " >&6; } if test ${ac_cv_sys_largefile_opts+y} then : printf %s "(cached) " >&6 else case e in @%:@( - e) ac_save_CC="$CC" + e) ac_save_CPPFLAGS=$CPPFLAGS ac_opt_found=no - for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1" "-n32"; do + for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1"; do if test x"$ac_opt" != x"none needed" then : - CC="$ac_save_CC $ac_opt" + CPPFLAGS="$ac_save_CPPFLAGS $ac_opt" fi cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -8736,12 +8909,12 @@ then : if test x"$ac_opt" = x"none needed" then : # GNU/Linux s390x and alpha need _FILE_OFFSET_BITS=64 for wide ino_t. - CC="$CC -DFTYPE=ino_t" + CPPFLAGS="$CPPFLAGS -DFTYPE=ino_t" if ac_fn_c_try_compile "$LINENO" then : else case e in @%:@( - e) CC="$CC -D_FILE_OFFSET_BITS=64" + e) CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64" if ac_fn_c_try_compile "$LINENO" then : ac_opt='-D_FILE_OFFSET_BITS=64' @@ -8757,7 +8930,7 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext test $ac_opt_found = no || break done - CC="$ac_save_CC" + CPPFLAGS=$ac_save_CPPFLAGS if test $ac_opt_found != yes; then @@ -8774,8 +8947,8 @@ esac test $ac_opt_found = yes || ac_cv_sys_largefile_opts="support not detected" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5 -printf "%s\n" "$ac_cv_sys_largefile_opts" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5 +printf '%s\n' "$ac_cv_sys_largefile_opts" >&6; } ac_have_largefile=yes case $ac_cv_sys_largefile_opts in @%:@( @@ -8787,22 +8960,20 @@ case $ac_cv_sys_largefile_opts in @%:@( ac_have_largefile=no ;; @%:@( "-D_FILE_OFFSET_BITS=64") : -printf "%s\n" "@%:@define _FILE_OFFSET_BITS 64" >>confdefs.h +printf '%s\n' "@%:@define _FILE_OFFSET_BITS 64" >>confdefs.h ;; @%:@( "-D_LARGE_FILES=1") : -printf "%s\n" "@%:@define _LARGE_FILES 1" >>confdefs.h +printf '%s\n' "@%:@define _LARGE_FILES 1" >>confdefs.h ;; @%:@( - "-n32") : - CC="$CC -n32" ;; @%:@( *) : as_fn_error $? "internal error: bad value for \$ac_cv_sys_largefile_opts" "$LINENO" 5 ;; esac if test "$enable_year2038" != no then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option for timestamps after 2038" >&5 -printf %s "checking for $CC option for timestamps after 2038... " >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support timestamps after 2038" >&5 +printf %s "checking for $CC option to support timestamps after 2038... " >&6; } if test ${ac_cv_sys_year2038_opts+y} then : printf %s "(cached) " >&6 @@ -8845,8 +9016,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext test $ac_opt_found = yes || ac_cv_sys_year2038_opts="support not detected" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5 -printf "%s\n" "$ac_cv_sys_year2038_opts" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5 +printf '%s\n' "$ac_cv_sys_year2038_opts" >&6; } ac_have_year2038=yes case $ac_cv_sys_year2038_opts in @%:@( @@ -8856,15 +9027,15 @@ case $ac_cv_sys_year2038_opts in @%:@( ac_have_year2038=no ;; @%:@( "-D_TIME_BITS=64") : -printf "%s\n" "@%:@define _TIME_BITS 64" >>confdefs.h +printf '%s\n' "@%:@define _TIME_BITS 64" >>confdefs.h ;; @%:@( "-D__MINGW_USE_VC2005_COMPAT") : -printf "%s\n" "@%:@define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h +printf '%s\n' "@%:@define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h ;; @%:@( "-U_USE_32_BIT_TIME_T"*) : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "the 'time_t' type is currently forced to be 32-bit. It will stop working after mid-January 2038. Remove _USE_32BIT_TIME_T from the compiler flags. @@ -9098,7 +9269,7 @@ fi # Code from module stdio: - printf "%s\n" "@%:@define __USE_MINGW_ANSI_STDIO 1" >>confdefs.h + printf '%s\n' "@%:@define __USE_MINGW_ANSI_STDIO 1" >>confdefs.h # Code from module stdlib: @@ -9171,7 +9342,7 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $ ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -Werror -Wunknown-warning-option" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -Werror -Wunknown-warning-option" >&5 printf %s "checking whether C compiler handles -Werror -Wunknown-warning-option... " >&6; } if test ${gl_cv_warn_c__Werror__Wunknown_warning_option+y} then : @@ -9204,8 +9375,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__Werror__Wunknown_warning_option" >&5 -printf "%s\n" "$gl_cv_warn_c__Werror__Wunknown_warning_option" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__Werror__Wunknown_warning_option" >&5 +printf '%s\n' "$gl_cv_warn_c__Werror__Wunknown_warning_option" >&6; } if test "x$gl_cv_warn_c__Werror__Wunknown_warning_option" = xyes then : gl_unknown_warnings_are_errors='-Wunknown-warning-option -Werror' @@ -9282,7 +9453,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$GCC" then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -Wno-missing-field-initializers is needed" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -Wno-missing-field-initializers is needed" >&5 printf %s "checking whether -Wno-missing-field-initializers is needed... " >&6; } if test ${gl_cv_cc_nomfi_needed+y} then : @@ -9328,10 +9499,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_nomfi_needed" >&5 -printf "%s\n" "$gl_cv_cc_nomfi_needed" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_nomfi_needed" >&5 +printf '%s\n' "$gl_cv_cc_nomfi_needed" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -Wuninitialized is supported" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -Wuninitialized is supported" >&5 printf %s "checking whether -Wuninitialized is supported... " >&6; } if test ${gl_cv_cc_uninitialized_supported+y} then : @@ -9362,8 +9533,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_uninitialized_supported" >&5 -printf "%s\n" "$gl_cv_cc_uninitialized_supported" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_uninitialized_supported" >&5 +printf '%s\n' "$gl_cv_cc_uninitialized_supported" >&6; } fi @@ -9516,12 +9687,12 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu for w in $desired_warning_options; do -as_gl_Warn=`printf "%s\n" "gl_cv_warn_c_$w" | sed "$as_sed_sh"` +as_gl_Warn=`printf '%s\n' "gl_cv_warn_c_$w" | sed "$as_sed_sh"` gl_positive="$w" case $gl_positive in -Wno-*) gl_positive=-W`expr "X$gl_positive" : 'X-Wno-\(.*\)'` ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 printf %s "checking whether C compiler handles $w... " >&6; } if eval test \${$as_gl_Warn+y} then : @@ -9555,8 +9726,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$as_gl_Warn - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_gl_Warn"\" = x"yes" then : as_fn_append WARN_CFLAGS " $w" @@ -9568,12 +9739,12 @@ fi for w in `echo "$remaining_undesired_warning_options" | sed -e 's/-W/-Wno-/g'`; do -as_gl_Warn=`printf "%s\n" "gl_cv_warn_c_$w" | sed "$as_sed_sh"` +as_gl_Warn=`printf '%s\n' "gl_cv_warn_c_$w" | sed "$as_sed_sh"` gl_positive="$w" case $gl_positive in -Wno-*) gl_positive=-W`expr "X$gl_positive" : 'X-Wno-\(.*\)'` ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 printf %s "checking whether C compiler handles $w... " >&6; } if eval test \${$as_gl_Warn+y} then : @@ -9607,8 +9778,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$as_gl_Warn - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_gl_Warn"\" = x"yes" then : as_fn_append WARN_CFLAGS " $w" @@ -9619,7 +9790,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -Wshadow=local" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -Wshadow=local" >&5 printf %s "checking whether C compiler handles -Wshadow=local... " >&6; } if test ${gl_cv_warn_c__Wshadow_local+y} then : @@ -9652,8 +9823,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__Wshadow_local" >&5 -printf "%s\n" "$gl_cv_warn_c__Wshadow_local" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__Wshadow_local" >&5 +printf '%s\n' "$gl_cv_warn_c__Wshadow_local" >&6; } if test "x$gl_cv_warn_c__Wshadow_local" = xyes then : as_fn_append WARN_CFLAGS " -Wshadow=local" @@ -9681,7 +9852,7 @@ then : -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -fno-analyzer" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -fno-analyzer" >&5 printf %s "checking whether C compiler handles -fno-analyzer... " >&6; } if test ${gl_cv_warn_c__fno_analyzer+y} then : @@ -9714,8 +9885,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__fno_analyzer" >&5 -printf "%s\n" "$gl_cv_warn_c__fno_analyzer" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__fno_analyzer" >&5 +printf '%s\n' "$gl_cv_warn_c__fno_analyzer" >&6; } if test "x$gl_cv_warn_c__fno_analyzer" = xyes then : as_fn_append WARN_CFLAGS " -fno-analyzer" @@ -9737,12 +9908,12 @@ rm -f conftest.err conftest.i conftest.$ac_ext for w in `echo "$fnw" | sed -e 's/-W/-Wno-/g'`; do -as_gl_Warn=`printf "%s\n" "gl_cv_warn_c_$w" | sed "$as_sed_sh"` +as_gl_Warn=`printf '%s\n' "gl_cv_warn_c_$w" | sed "$as_sed_sh"` gl_positive="$w" case $gl_positive in -Wno-*) gl_positive=-W`expr "X$gl_positive" : 'X-Wno-\(.*\)'` ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles $w" >&5 printf %s "checking whether C compiler handles $w... " >&6; } if eval test \${$as_gl_Warn+y} then : @@ -9776,8 +9947,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$as_gl_Warn - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if eval test \"x\$"$as_gl_Warn"\" = x"yes" then : as_fn_append FOREIGN_WARN_CFLAGS " $w" @@ -9788,7 +9959,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -fno-analyzer" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C compiler handles -fno-analyzer" >&5 printf %s "checking whether C compiler handles -fno-analyzer... " >&6; } if test ${gl_cv_warn_c__fno_analyzer+y} then : @@ -9821,8 +9992,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__fno_analyzer" >&5 -printf "%s\n" "$gl_cv_warn_c__fno_analyzer" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_warn_c__fno_analyzer" >&5 +printf '%s\n' "$gl_cv_warn_c__fno_analyzer" >&6; } if test "x$gl_cv_warn_c__fno_analyzer" = xyes then : as_fn_append NO_EXPENSIVE_WARN_CFLAGS " -fno-analyzer" @@ -9839,7 +10010,7 @@ fi case "$host_os" in mingw* | cygwin*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for auto-import of symbols" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for auto-import of symbols" >&5 printf %s "checking for auto-import of symbols... " >&6; } if test ${gl_cv_ld_autoimport+y} then : @@ -9878,8 +10049,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_ld_autoimport" >&5 -printf "%s\n" "$gl_cv_ld_autoimport" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_ld_autoimport" >&5 +printf '%s\n' "$gl_cv_ld_autoimport" >&6; } if test $gl_cv_ld_autoimport = yes; then LDFLAGS="$LDFLAGS -Wl,--disable-auto-import" fi @@ -9889,8 +10060,8 @@ printf "%s\n" "$gl_cv_ld_autoimport" >&6; } case `pwd` in *\ * | *\ *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 -printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 +printf '%s\n' "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; esac @@ -9934,7 +10105,7 @@ ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 printf %s "checking how to print strings... " >&6; } # Test print first, because it will be a builtin if present. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ @@ -9961,12 +10132,12 @@ func_echo_all () } case $ECHO in - printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5 -printf "%s\n" "printf" >&6; } ;; - print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 -printf "%s\n" "print -r" >&6; } ;; - *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5 -printf "%s\n" "cat" >&6; } ;; + printf*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: printf" >&5 +printf '%s\n' "printf" >&6; } ;; + print*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 +printf '%s\n' "print -r" >&6; } ;; + *) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: cat" >&5 +printf '%s\n' "cat" >&6; } ;; esac @@ -9982,7 +10153,7 @@ esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 printf %s "checking for a sed that does not truncate output... " >&6; } if test ${ac_cv_path_SED+y} then : @@ -10025,7 +10196,7 @@ case `"$ac_path_SED" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" '' >> "conftest.nl" + printf '%s\n' '' >> "conftest.nl" "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -10054,8 +10225,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 -printf "%s\n" "$ac_cv_path_SED" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +printf '%s\n' "$ac_cv_path_SED" >&6; } SED="$ac_cv_path_SED" rm -f conftest.sed @@ -10072,7 +10243,7 @@ Xsed="$SED -e 1s/^X//" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 printf %s "checking for grep that handles long lines and -e... " >&6; } if test ${ac_cv_path_GREP+y} then : @@ -10109,7 +10280,7 @@ case `"$ac_path_GREP" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'GREP' >> "conftest.nl" + printf '%s\n' 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -10138,12 +10309,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -printf "%s\n" "$ac_cv_path_GREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +printf '%s\n' "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 printf %s "checking for egrep... " >&6; } if test ${ac_cv_path_EGREP+y} then : @@ -10183,7 +10354,7 @@ case `"$ac_path_EGREP" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'EGREP' >> "conftest.nl" + printf '%s\n' 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -10213,14 +10384,14 @@ fi fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -printf "%s\n" "$ac_cv_path_EGREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +printf '%s\n' "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" EGREP_TRADITIONAL=$EGREP ac_cv_path_EGREP_TRADITIONAL=$EGREP -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 printf %s "checking for fgrep... " >&6; } if test ${ac_cv_path_FGREP+y} then : @@ -10260,7 +10431,7 @@ case `"$ac_path_FGREP" --version 2>&1` in @%:@( cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" - printf "%s\n" 'FGREP' >> "conftest.nl" + printf '%s\n' 'FGREP' >> "conftest.nl" "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val @@ -10290,8 +10461,8 @@ fi fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 -printf "%s\n" "$ac_cv_path_FGREP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +printf '%s\n' "$ac_cv_path_FGREP" >&6; } FGREP="$ac_cv_path_FGREP" @@ -10327,7 +10498,7 @@ fi ac_prog=ld if test yes = "$GCC"; then # Check if gcc -print-prog-name=ld gives a path. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 printf %s "checking for ld used by $CC... " >&6; } case $host in *-*-mingw* | *-*-windows*) @@ -10357,10 +10528,10 @@ printf %s "checking for ld used by $CC... " >&6; } ;; esac elif test yes = "$with_gnu_ld"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 printf %s "checking for GNU ld... " >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 printf %s "checking for non-GNU ld... " >&6; } fi if test ${lt_cv_path_LD+y} @@ -10396,14 +10567,14 @@ fi LD=$lt_cv_path_LD if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -printf "%s\n" "$LD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +printf '%s\n' "$LD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${lt_cv_prog_gnu_ld+y} then : @@ -10420,8 +10591,8 @@ case `$LD -v 2>&1 &5 -printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5 +printf '%s\n' "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld @@ -10432,7 +10603,7 @@ with_gnu_ld=$lt_cv_prog_gnu_ld -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; } if test ${lt_cv_path_NM+y} then : @@ -10488,8 +10659,8 @@ else fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 -printf "%s\n" "$lt_cv_path_NM" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +printf '%s\n' "$lt_cv_path_NM" >&6; } if test no != "$lt_cv_path_NM"; then NM=$lt_cv_path_NM else @@ -10502,7 +10673,7 @@ else do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DUMPBIN+y} then : @@ -10523,7 +10694,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10535,11 +10706,11 @@ esac fi DUMPBIN=$ac_cv_prog_DUMPBIN if test -n "$DUMPBIN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 -printf "%s\n" "$DUMPBIN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +printf '%s\n' "$DUMPBIN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10552,7 +10723,7 @@ if test -z "$DUMPBIN"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DUMPBIN+y} then : @@ -10573,7 +10744,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10585,11 +10756,11 @@ esac fi ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN if test -n "$ac_ct_DUMPBIN"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 -printf "%s\n" "$ac_ct_DUMPBIN" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 +printf '%s\n' "$ac_ct_DUMPBIN" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -10601,8 +10772,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DUMPBIN=$ac_ct_DUMPBIN @@ -10630,7 +10801,7 @@ test -z "$NM" && NM=nm -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 printf %s "checking the name lister ($NM) interface... " >&6; } if test ${lt_cv_nm_interface+y} then : @@ -10652,22 +10823,22 @@ else case e in @%:@( rm -f conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 -printf "%s\n" "$lt_cv_nm_interface" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 +printf '%s\n' "$lt_cv_nm_interface" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 printf %s "checking whether ln -s works... " >&6; } LN_S=$as_ln_s if test "$LN_S" = "ln -s"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 -printf "%s\n" "no, using $LN_S" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +printf '%s\n' "no, using $LN_S" >&6; } fi # find the maximum length of command line arguments -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 printf %s "checking the maximum length of command line arguments... " >&6; } if test ${lt_cv_sys_max_cmd_len+y} then : @@ -10800,11 +10971,11 @@ esac fi if test -n "$lt_cv_sys_max_cmd_len"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 -printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +printf '%s\n' "$lt_cv_sys_max_cmd_len" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5 -printf "%s\n" "none" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none" >&5 +printf '%s\n' "none" >&6; } fi max_cmd_len=$lt_cv_sys_max_cmd_len @@ -10848,7 +11019,7 @@ esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 printf %s "checking how to convert $build file names to $host format... " >&6; } if test ${lt_cv_to_host_file_cmd+y} then : @@ -10890,14 +11061,14 @@ esac fi to_host_file_cmd=$lt_cv_to_host_file_cmd -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 -printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 +printf '%s\n' "$lt_cv_to_host_file_cmd" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 printf %s "checking how to convert $build file names to toolchain format... " >&6; } if test ${lt_cv_to_tool_file_cmd+y} then : @@ -10919,14 +11090,14 @@ esac fi to_tool_file_cmd=$lt_cv_to_tool_file_cmd -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 -printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 +printf '%s\n' "$lt_cv_to_tool_file_cmd" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 printf %s "checking for $LD option to reload object files... " >&6; } if test ${lt_cv_ld_reload_flag+y} then : @@ -10935,8 +11106,8 @@ else case e in @%:@( e) lt_cv_ld_reload_flag='-r' ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 -printf "%s\n" "$lt_cv_ld_reload_flag" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +printf '%s\n' "$lt_cv_ld_reload_flag" >&6; } reload_flag=$lt_cv_ld_reload_flag case $reload_flag in "" | " "*) ;; @@ -10968,7 +11139,7 @@ esac # Extract the first word of "file", so it can be a program name with args. set dummy file; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_FILECMD+y} then : @@ -10989,7 +11160,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_FILECMD="file" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11002,11 +11173,11 @@ esac fi FILECMD=$ac_cv_prog_FILECMD if test -n "$FILECMD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILECMD" >&5 -printf "%s\n" "$FILECMD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $FILECMD" >&5 +printf '%s\n' "$FILECMD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11019,7 +11190,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OBJDUMP+y} then : @@ -11040,7 +11211,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11052,11 +11223,11 @@ esac fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 -printf "%s\n" "$OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +printf '%s\n' "$OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11065,7 +11236,7 @@ if test -z "$ac_cv_prog_OBJDUMP"; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of "objdump", so it can be a program name with args. set dummy objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OBJDUMP+y} then : @@ -11086,7 +11257,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJDUMP="objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11098,11 +11269,11 @@ esac fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 -printf "%s\n" "$ac_ct_OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +printf '%s\n' "$ac_ct_OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OBJDUMP" = x; then @@ -11110,8 +11281,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP @@ -11127,7 +11298,7 @@ test -z "$OBJDUMP" && OBJDUMP=objdump -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 printf %s "checking how to recognize dependent libraries... " >&6; } if test ${lt_cv_deplibs_check_method+y} then : @@ -11340,8 +11511,8 @@ esac ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 -printf "%s\n" "$lt_cv_deplibs_check_method" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +printf '%s\n' "$lt_cv_deplibs_check_method" >&6; } file_magic_glob= want_nocaseglob=no @@ -11385,7 +11556,7 @@ test -z "$deplibs_check_method" && deplibs_check_method=unknown if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DLLTOOL+y} then : @@ -11406,7 +11577,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11418,11 +11589,11 @@ esac fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 -printf "%s\n" "$DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +printf '%s\n' "$DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11431,7 +11602,7 @@ if test -z "$ac_cv_prog_DLLTOOL"; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of "dlltool", so it can be a program name with args. set dummy dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DLLTOOL+y} then : @@ -11452,7 +11623,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DLLTOOL="dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11464,11 +11635,11 @@ esac fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 -printf "%s\n" "$ac_ct_DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +printf '%s\n' "$ac_ct_DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DLLTOOL" = x; then @@ -11476,8 +11647,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL @@ -11494,7 +11665,7 @@ test -z "$DLLTOOL" && DLLTOOL=dlltool -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 printf %s "checking how to associate runtime and link libraries... " >&6; } if test ${lt_cv_sharedlib_from_linklib_cmd+y} then : @@ -11523,8 +11694,8 @@ esac ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 -printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 +printf '%s\n' "$lt_cv_sharedlib_from_linklib_cmd" >&6; } sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO @@ -11539,7 +11710,7 @@ if test -n "$ac_tool_prefix"; then do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AR+y} then : @@ -11560,7 +11731,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AR="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11572,11 +11743,11 @@ esac fi AR=$ac_cv_prog_AR if test -n "$AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 -printf "%s\n" "$AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +printf '%s\n' "$AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11589,7 +11760,7 @@ if test -z "$AR"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_AR+y} then : @@ -11610,7 +11781,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AR="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11622,11 +11793,11 @@ esac fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 -printf "%s\n" "$ac_ct_AR" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +printf '%s\n' "$ac_ct_AR" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11638,8 +11809,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AR=$ac_ct_AR @@ -11675,7 +11846,7 @@ lt_ar_flags=$AR_FLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 printf %s "checking for archiver @FILE support... " >&6; } if test ${lt_cv_ar_at_file+y} then : @@ -11700,7 +11871,7 @@ then : { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test 0 -eq "$ac_status"; then # Ensure the archiver fails upon bogus file names. @@ -11708,7 +11879,7 @@ then : { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 (eval $lt_ar_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if test 0 -ne "$ac_status"; then lt_cv_ar_at_file=@ @@ -11721,8 +11892,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 -printf "%s\n" "$lt_cv_ar_at_file" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 +printf '%s\n' "$lt_cv_ar_at_file" >&6; } if test no = "$lt_cv_ar_at_file"; then archiver_list_spec= @@ -11739,7 +11910,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. set dummy ${ac_tool_prefix}strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : @@ -11760,7 +11931,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_STRIP="${ac_tool_prefix}strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11772,11 +11943,11 @@ esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 -printf "%s\n" "$STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +printf '%s\n' "$STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -11785,7 +11956,7 @@ if test -z "$ac_cv_prog_STRIP"; then ac_ct_STRIP=$STRIP # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : @@ -11806,7 +11977,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_STRIP="strip" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11818,11 +11989,11 @@ esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 -printf "%s\n" "$ac_ct_STRIP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +printf '%s\n' "$ac_ct_STRIP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_STRIP" = x; then @@ -11830,8 +12001,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac STRIP=$ac_ct_STRIP @@ -11921,7 +12092,7 @@ compiler=$CC # Check for command to grab the raw symbol name followed by C symbol from nm. -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 printf %s "checking command to parse $NM output from $compiler object... " >&6; } if test ${lt_cv_sys_global_symbol_pipe+y} then : @@ -12078,7 +12249,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Now try to grab the symbols. nlist=conftest.nm @@ -12151,7 +12322,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then pipe_works=yes fi @@ -12187,11 +12358,11 @@ if test -z "$lt_cv_sys_global_symbol_pipe"; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: failed" >&5 -printf "%s\n" "failed" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +printf '%s\n' "failed" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5 -printf "%s\n" "ok" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +printf '%s\n' "ok" >&6; } fi # Response file support. @@ -12237,7 +12408,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 printf %s "checking for sysroot... " >&6; } @%:@ Check whether --with-sysroot was given. @@ -12265,20 +12436,20 @@ case $with_sysroot in #( no|'') ;; #( *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5 -printf "%s\n" "$with_sysroot" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5 +printf '%s\n' "$with_sysroot" >&6; } as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 -printf "%s\n" "${lt_sysroot:-no}" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 +printf '%s\n' "${lt_sysroot:-no}" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5 printf %s "checking for a working dd... " >&6; } if test ${ac_cv_path_lt_DD+y} then : @@ -12323,11 +12494,11 @@ fi rm -f conftest.i conftest2.i conftest.out ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 -printf "%s\n" "$ac_cv_path_lt_DD" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 +printf '%s\n' "$ac_cv_path_lt_DD" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5 printf %s "checking how to truncate binary pipes... " >&6; } if test ${lt_cv_truncate_bin+y} then : @@ -12344,8 +12515,8 @@ rm -f conftest.i conftest2.i conftest.out test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 -printf "%s\n" "$lt_cv_truncate_bin" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 +printf '%s\n' "$lt_cv_truncate_bin" >&6; } @@ -12385,7 +12556,7 @@ ia64-*-hpux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `$FILECMD conftest.$ac_objext` in *ELF-32*) @@ -12405,7 +12576,7 @@ ia64-*-hpux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then if test yes = "$lt_cv_prog_gnu_ld"; then case `$FILECMD conftest.$ac_objext` in @@ -12443,7 +12614,7 @@ mips64*-*linux*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then emul=elf case `$FILECMD conftest.$ac_objext` in @@ -12484,7 +12655,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*|x86_64-gnu*) if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `$FILECMD conftest.o` in *32-bit*) @@ -12547,7 +12718,7 @@ s390*-*linux*|s390*-*tpf*|sparc*-*linux*|x86_64-gnu*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS=$CFLAGS CFLAGS="$CFLAGS -belf" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 printf %s "checking whether the C compiler needs -belf... " >&6; } if test ${lt_cv_cc_needs_belf+y} then : @@ -12587,8 +12758,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 -printf "%s\n" "$lt_cv_cc_needs_belf" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +printf '%s\n' "$lt_cv_cc_needs_belf" >&6; } if test yes != "$lt_cv_cc_needs_belf"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS=$SAVE_CFLAGS @@ -12601,7 +12772,7 @@ printf "%s\n" "$lt_cv_cc_needs_belf" >&6; } if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then case `$FILECMD conftest.o` in *64-bit*) @@ -12638,7 +12809,7 @@ need_locks=$enable_libtool_lock if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. set dummy ${ac_tool_prefix}mt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_MANIFEST_TOOL+y} then : @@ -12659,7 +12830,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12671,11 +12842,11 @@ esac fi MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL if test -n "$MANIFEST_TOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 -printf "%s\n" "$MANIFEST_TOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 +printf '%s\n' "$MANIFEST_TOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -12684,7 +12855,7 @@ if test -z "$ac_cv_prog_MANIFEST_TOOL"; then ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL # Extract the first word of "mt", so it can be a program name with args. set dummy mt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y} then : @@ -12705,7 +12876,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12717,11 +12888,11 @@ esac fi ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL if test -n "$ac_ct_MANIFEST_TOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 -printf "%s\n" "$ac_ct_MANIFEST_TOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 +printf '%s\n' "$ac_ct_MANIFEST_TOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_MANIFEST_TOOL" = x; then @@ -12729,8 +12900,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL @@ -12740,7 +12911,7 @@ else fi test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } if test ${lt_cv_path_manifest_tool+y} then : @@ -12756,8 +12927,8 @@ else case e in @%:@( rm -f conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_manifest_tool" >&5 -printf "%s\n" "$lt_cv_path_manifest_tool" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_manifest_tool" >&5 +printf '%s\n' "$lt_cv_path_manifest_tool" >&6; } if test yes != "$lt_cv_path_manifest_tool"; then MANIFEST_TOOL=: fi @@ -12772,7 +12943,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DSYMUTIL+y} then : @@ -12793,7 +12964,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12805,11 +12976,11 @@ esac fi DSYMUTIL=$ac_cv_prog_DSYMUTIL if test -n "$DSYMUTIL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 -printf "%s\n" "$DSYMUTIL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 +printf '%s\n' "$DSYMUTIL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -12818,7 +12989,7 @@ if test -z "$ac_cv_prog_DSYMUTIL"; then ac_ct_DSYMUTIL=$DSYMUTIL # Extract the first word of "dsymutil", so it can be a program name with args. set dummy dsymutil; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DSYMUTIL+y} then : @@ -12839,7 +13010,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12851,11 +13022,11 @@ esac fi ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL if test -n "$ac_ct_DSYMUTIL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 -printf "%s\n" "$ac_ct_DSYMUTIL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 +printf '%s\n' "$ac_ct_DSYMUTIL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DSYMUTIL" = x; then @@ -12863,8 +13034,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DSYMUTIL=$ac_ct_DSYMUTIL @@ -12876,7 +13047,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. set dummy ${ac_tool_prefix}nmedit; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_NMEDIT+y} then : @@ -12897,7 +13068,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12909,11 +13080,11 @@ esac fi NMEDIT=$ac_cv_prog_NMEDIT if test -n "$NMEDIT"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 -printf "%s\n" "$NMEDIT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 +printf '%s\n' "$NMEDIT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -12922,7 +13093,7 @@ if test -z "$ac_cv_prog_NMEDIT"; then ac_ct_NMEDIT=$NMEDIT # Extract the first word of "nmedit", so it can be a program name with args. set dummy nmedit; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_NMEDIT+y} then : @@ -12943,7 +13114,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_NMEDIT="nmedit" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12955,11 +13126,11 @@ esac fi ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT if test -n "$ac_ct_NMEDIT"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 -printf "%s\n" "$ac_ct_NMEDIT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 +printf '%s\n' "$ac_ct_NMEDIT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_NMEDIT" = x; then @@ -12967,8 +13138,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac NMEDIT=$ac_ct_NMEDIT @@ -12980,7 +13151,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. set dummy ${ac_tool_prefix}lipo; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_LIPO+y} then : @@ -13001,7 +13172,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_LIPO="${ac_tool_prefix}lipo" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13013,11 +13184,11 @@ esac fi LIPO=$ac_cv_prog_LIPO if test -n "$LIPO"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 -printf "%s\n" "$LIPO" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 +printf '%s\n' "$LIPO" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13026,7 +13197,7 @@ if test -z "$ac_cv_prog_LIPO"; then ac_ct_LIPO=$LIPO # Extract the first word of "lipo", so it can be a program name with args. set dummy lipo; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_LIPO+y} then : @@ -13047,7 +13218,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_LIPO="lipo" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13059,11 +13230,11 @@ esac fi ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO if test -n "$ac_ct_LIPO"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 -printf "%s\n" "$ac_ct_LIPO" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 +printf '%s\n' "$ac_ct_LIPO" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_LIPO" = x; then @@ -13071,8 +13242,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac LIPO=$ac_ct_LIPO @@ -13084,7 +13255,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. set dummy ${ac_tool_prefix}otool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL+y} then : @@ -13105,7 +13276,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL="${ac_tool_prefix}otool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13117,11 +13288,11 @@ esac fi OTOOL=$ac_cv_prog_OTOOL if test -n "$OTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 -printf "%s\n" "$OTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +printf '%s\n' "$OTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13130,7 +13301,7 @@ if test -z "$ac_cv_prog_OTOOL"; then ac_ct_OTOOL=$OTOOL # Extract the first word of "otool", so it can be a program name with args. set dummy otool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL+y} then : @@ -13151,7 +13322,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL="otool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13163,11 +13334,11 @@ esac fi ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL if test -n "$ac_ct_OTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 -printf "%s\n" "$ac_ct_OTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 +printf '%s\n' "$ac_ct_OTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OTOOL" = x; then @@ -13175,8 +13346,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL=$ac_ct_OTOOL @@ -13188,7 +13359,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. set dummy ${ac_tool_prefix}otool64; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL64+y} then : @@ -13209,7 +13380,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13221,11 +13392,11 @@ esac fi OTOOL64=$ac_cv_prog_OTOOL64 if test -n "$OTOOL64"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 -printf "%s\n" "$OTOOL64" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 +printf '%s\n' "$OTOOL64" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13234,7 +13405,7 @@ if test -z "$ac_cv_prog_OTOOL64"; then ac_ct_OTOOL64=$OTOOL64 # Extract the first word of "otool64", so it can be a program name with args. set dummy otool64; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL64+y} then : @@ -13255,7 +13426,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OTOOL64="otool64" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13267,11 +13438,11 @@ esac fi ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 if test -n "$ac_ct_OTOOL64"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 -printf "%s\n" "$ac_ct_OTOOL64" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 +printf '%s\n' "$ac_ct_OTOOL64" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OTOOL64" = x; then @@ -13279,8 +13450,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OTOOL64=$ac_ct_OTOOL64 @@ -13315,7 +13486,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 printf %s "checking for -single_module linker flag... " >&6; } if test ${lt_cv_apple_cc_single_mod+y} then : @@ -13350,12 +13521,12 @@ else case e in @%:@( fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 -printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 +printf '%s\n' "$lt_cv_apple_cc_single_mod" >&6; } # Feature test to disable chained fixups since it is not # compatible with '-undefined dynamic_lookup' - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -no_fixup_chains linker flag" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -no_fixup_chains linker flag" >&5 printf %s "checking for -no_fixup_chains linker flag... " >&6; } if test ${lt_cv_support_no_fixup_chains+y} then : @@ -13389,10 +13560,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_support_no_fixup_chains" >&5 -printf "%s\n" "$lt_cv_support_no_fixup_chains" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_support_no_fixup_chains" >&5 +printf '%s\n' "$lt_cv_support_no_fixup_chains" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 printf %s "checking for -exported_symbols_list linker flag... " >&6; } if test ${lt_cv_ld_exported_symbols_list+y} then : @@ -13426,10 +13597,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 -printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 +printf '%s\n' "$lt_cv_ld_exported_symbols_list" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 printf %s "checking for -force_load linker flag... " >&6; } if test ${lt_cv_ld_force_load+y} then : @@ -13463,8 +13634,8 @@ _LT_EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 -printf "%s\n" "$lt_cv_ld_force_load" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 +printf '%s\n' "$lt_cv_ld_force_load" >&6; } case $host_os in rhapsody* | darwin1.[012]) _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;; @@ -13553,7 +13724,7 @@ ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_inc " if test "x$ac_cv_header_dlfcn_h" = xyes then : - printf "%s\n" "@%:@define HAVE_DLFCN_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_DLFCN_H 1" >>confdefs.h fi @@ -13580,7 +13751,7 @@ case $host in if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. set dummy ${ac_tool_prefix}as; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AS+y} then : @@ -13601,7 +13772,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AS="${ac_tool_prefix}as" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13613,11 +13784,11 @@ esac fi AS=$ac_cv_prog_AS if test -n "$AS"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 -printf "%s\n" "$AS" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 +printf '%s\n' "$AS" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13626,7 +13797,7 @@ if test -z "$ac_cv_prog_AS"; then ac_ct_AS=$AS # Extract the first word of "as", so it can be a program name with args. set dummy as; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_AS+y} then : @@ -13647,7 +13818,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_AS="as" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13659,11 +13830,11 @@ esac fi ac_ct_AS=$ac_cv_prog_ac_ct_AS if test -n "$ac_ct_AS"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5 -printf "%s\n" "$ac_ct_AS" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5 +printf '%s\n' "$ac_ct_AS" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_AS" = x; then @@ -13671,8 +13842,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac AS=$ac_ct_AS @@ -13684,7 +13855,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. set dummy ${ac_tool_prefix}dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DLLTOOL+y} then : @@ -13705,7 +13876,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13717,11 +13888,11 @@ esac fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 -printf "%s\n" "$DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +printf '%s\n' "$DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13730,7 +13901,7 @@ if test -z "$ac_cv_prog_DLLTOOL"; then ac_ct_DLLTOOL=$DLLTOOL # Extract the first word of "dlltool", so it can be a program name with args. set dummy dlltool; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DLLTOOL+y} then : @@ -13751,7 +13922,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_DLLTOOL="dlltool" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13763,11 +13934,11 @@ esac fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 -printf "%s\n" "$ac_ct_DLLTOOL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +printf '%s\n' "$ac_ct_DLLTOOL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_DLLTOOL" = x; then @@ -13775,8 +13946,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac DLLTOOL=$ac_ct_DLLTOOL @@ -13788,7 +13959,7 @@ fi if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. set dummy ${ac_tool_prefix}objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OBJDUMP+y} then : @@ -13809,7 +13980,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13821,11 +13992,11 @@ esac fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 -printf "%s\n" "$OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +printf '%s\n' "$OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -13834,7 +14005,7 @@ if test -z "$ac_cv_prog_OBJDUMP"; then ac_ct_OBJDUMP=$OBJDUMP # Extract the first word of "objdump", so it can be a program name with args. set dummy objdump; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OBJDUMP+y} then : @@ -13855,7 +14026,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_OBJDUMP="objdump" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13867,11 +14038,11 @@ esac fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 -printf "%s\n" "$ac_ct_OBJDUMP" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +printf '%s\n' "$ac_ct_OBJDUMP" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_OBJDUMP" = x; then @@ -13879,8 +14050,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac OBJDUMP=$ac_ct_OBJDUMP @@ -14072,7 +14243,7 @@ fi shared_archive_member_spec= case $host,$enable_shared in power*-*-aix[5-9]*,yes) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5 printf %s "checking which variant of shared library versioning to provide... " >&6; } @%:@ Check whether --enable-aix-soname was given. if test ${enable_aix_soname+y} @@ -14114,8 +14285,8 @@ esac fi with_aix_soname=$enable_aix_soname - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 -printf "%s\n" "$with_aix_soname" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 +printf '%s\n' "$with_aix_soname" >&6; } if test aix != "$with_aix_soname"; then # For the AIX way of multilib, we name the shared archive member # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o', @@ -14197,7 +14368,7 @@ if test -n "${ZSH_VERSION+set}"; then setopt NO_GLOB_SUBST fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 printf %s "checking for objdir... " >&6; } if test ${lt_cv_objdir+y} then : @@ -14214,15 +14385,15 @@ fi rmdir .libs 2>/dev/null ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 -printf "%s\n" "$lt_cv_objdir" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +printf '%s\n' "$lt_cv_objdir" >&6; } objdir=$lt_cv_objdir -printf "%s\n" "@%:@define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h +printf '%s\n' "@%:@define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h @@ -14268,7 +14439,7 @@ test -z "$MAGIC_CMD" && MAGIC_CMD=file case $deplibs_check_method in file_magic*) if test "$file_magic_cmd" = '$MAGIC_CMD'; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 printf %s "checking for ${ac_tool_prefix}file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : @@ -14323,11 +14494,11 @@ fi MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 -printf "%s\n" "$MAGIC_CMD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +printf '%s\n' "$MAGIC_CMD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -14336,7 +14507,7 @@ fi if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for file" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for file" >&5 printf %s "checking for file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : @@ -14391,11 +14562,11 @@ fi MAGIC_CMD=$lt_cv_path_MAGIC_CMD if test -n "$MAGIC_CMD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 -printf "%s\n" "$MAGIC_CMD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +printf '%s\n' "$MAGIC_CMD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -14464,10 +14635,6 @@ _lt_linker_boilerplate=`cat conftest.err` $RM -r conftest* -## CAVEAT EMPTOR: -## There is no encapsulation within the following macros, do not change -## the running order or otherwise move them around unless you know exactly -## what you are doing... if test -n "$compiler"; then lt_prog_compiler_no_builtin_flag= @@ -14480,7 +14647,7 @@ if test yes = "$GCC"; then lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } if test ${lt_cv_prog_compiler_rtti_exceptions+y} then : @@ -14517,8 +14684,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 -printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +printf '%s\n' "$lt_cv_prog_compiler_rtti_exceptions" >&6; } if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" @@ -14896,7 +15063,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic+y} then : @@ -14905,15 +15072,15 @@ else case e in @%:@( e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic" >&6; } lt_prog_compiler_pic=$lt_cv_prog_compiler_pic # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } if test ${lt_cv_prog_compiler_pic_works+y} then : @@ -14950,8 +15117,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works" >&6; } if test yes = "$lt_cv_prog_compiler_pic_works"; then case $lt_prog_compiler_pic in @@ -14979,7 +15146,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works+y} then : @@ -15009,8 +15176,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works" >&6; } if test yes = "$lt_cv_prog_compiler_static_works"; then : @@ -15024,7 +15191,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : @@ -15073,15 +15240,15 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : @@ -15130,8 +15297,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; } @@ -15139,7 +15306,7 @@ printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } hard_links=nottested if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then # do not overwrite the value of need_locks provided by the user - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 printf %s "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* @@ -15147,11 +15314,11 @@ printf %s "checking if we can lock with hard links... " >&6; } touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 -printf "%s\n" "$hard_links" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +printf '%s\n' "$hard_links" >&6; } if test no = "$hard_links"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5 -printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5 +printf '%s\n' "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;} need_locks=warn fi else @@ -15163,7 +15330,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } runpath_var= @@ -16068,7 +16235,7 @@ fi # Older versions of the 11.00 compiler do not understand -b yet # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 printf %s "checking if $CC understands -b... " >&6; } if test ${lt_cv_prog_compiler__b+y} then : @@ -16098,8 +16265,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 -printf "%s\n" "$lt_cv_prog_compiler__b" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 +printf '%s\n' "$lt_cv_prog_compiler__b" >&6; } if test yes = "$lt_cv_prog_compiler__b"; then archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' @@ -16139,7 +16306,7 @@ fi # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&6; } if test ${lt_cv_irix_exported_symbol+y} then : @@ -16163,8 +16330,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LDFLAGS=$save_LDFLAGS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 -printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 +printf '%s\n' "$lt_cv_irix_exported_symbol" >&6; } if test yes = "$lt_cv_irix_exported_symbol"; then archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib' fi @@ -16455,8 +16622,8 @@ printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; } fi fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 -printf "%s\n" "$ld_shlibs" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +printf '%s\n' "$ld_shlibs" >&6; } test no = "$ld_shlibs" && can_build_shared=no with_gnu_ld=$with_gnu_ld @@ -16492,7 +16659,7 @@ x|xyes) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 printf %s "checking whether -lc should be explicitly linked in... " >&6; } if test ${lt_cv_archive_cmds_need_lc+y} then : @@ -16504,7 +16671,7 @@ else case e in @%:@( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest @@ -16522,7 +16689,7 @@ else case e in @%:@( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc=no @@ -16537,8 +16704,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 -printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 +printf '%s\n' "$lt_cv_archive_cmds_need_lc" >&6; } archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc ;; esac @@ -16697,7 +16864,7 @@ esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 printf %s "checking dynamic linker characteristics... " >&6; } if test yes = "$GCC"; then @@ -17970,7 +18137,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic+y} then : @@ -17979,15 +18146,15 @@ else case e in @%:@( e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic" >&6; } lt_prog_compiler_pic=$lt_cv_prog_compiler_pic # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } if test ${lt_cv_prog_compiler_pic_works+y} then : @@ -18024,8 +18191,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works" >&6; } if test yes = "$lt_cv_prog_compiler_pic_works"; then case $lt_prog_compiler_pic in @@ -18047,7 +18214,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works+y} then : @@ -18077,8 +18244,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works" >&6; } if test yes = "$lt_cv_prog_compiler_static_works"; then : @@ -18099,8 +18266,8 @@ fi dynamic_linker=no ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 -printf "%s\n" "$dynamic_linker" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +printf '%s\n' "$dynamic_linker" >&6; } test no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" @@ -18221,7 +18388,7 @@ configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 printf %s "checking how to hardcode library paths into programs... " >&6; } hardcode_action= if test -n "$hardcode_libdir_flag_spec" || @@ -18246,8 +18413,8 @@ else # directories. hardcode_action=unsupported fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 -printf "%s\n" "$hardcode_action" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +printf '%s\n' "$hardcode_action" >&6; } if test relink = "$hardcode_action" || test yes = "$inherit_rpath"; then @@ -18291,7 +18458,7 @@ else darwin*) # if libdl is installed we need to link against it - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : @@ -18332,8 +18499,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl @@ -18362,7 +18529,7 @@ if test "x$ac_cv_func_shl_load" = xyes then : lt_cv_dlopen=shl_load else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 printf %s "checking for shl_load in -ldld... " >&6; } if test ${ac_cv_lib_dld_shl_load+y} then : @@ -18403,8 +18570,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 -printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +printf '%s\n' "$ac_cv_lib_dld_shl_load" >&6; } if test "x$ac_cv_lib_dld_shl_load" = xyes then : lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld @@ -18414,7 +18581,7 @@ if test "x$ac_cv_func_dlopen" = xyes then : lt_cv_dlopen=dlopen else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : @@ -18455,13 +18622,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 printf %s "checking for dlopen in -lsvld... " >&6; } if test ${ac_cv_lib_svld_dlopen+y} then : @@ -18502,13 +18669,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 -printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +printf '%s\n' "$ac_cv_lib_svld_dlopen" >&6; } if test "x$ac_cv_lib_svld_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 printf %s "checking for dld_link in -ldld... " >&6; } if test ${ac_cv_lib_dld_dld_link+y} then : @@ -18549,8 +18716,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 -printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +printf '%s\n' "$ac_cv_lib_dld_dld_link" >&6; } if test "x$ac_cv_lib_dld_dld_link" = xyes then : lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld @@ -18596,7 +18763,7 @@ fi save_LIBS=$LIBS LIBS="$lt_cv_dlopen_libs $LIBS" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 printf %s "checking whether a program can dlopen itself... " >&6; } if test ${lt_cv_dlopen_self+y} then : @@ -18680,7 +18847,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? @@ -18699,12 +18866,12 @@ rm -fr conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 -printf "%s\n" "$lt_cv_dlopen_self" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +printf '%s\n' "$lt_cv_dlopen_self" >&6; } if test yes = "$lt_cv_dlopen_self"; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 printf %s "checking whether a statically linked program can dlopen itself... " >&6; } if test ${lt_cv_dlopen_self_static+y} then : @@ -18788,7 +18955,7 @@ _LT_EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then (./conftest; exit; ) >&5 2>/dev/null lt_status=$? @@ -18807,8 +18974,8 @@ rm -fr conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 -printf "%s\n" "$lt_cv_dlopen_self_static" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +printf '%s\n' "$lt_cv_dlopen_self_static" >&6; } fi CPPFLAGS=$save_CPPFLAGS @@ -18846,40 +19013,40 @@ fi striplib= old_striplib= -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 printf %s "checking whether stripping libraries is possible... " >&6; } if test -z "$STRIP"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } else if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then old_striplib="$STRIP --strip-debug" striplib="$STRIP --strip-unneeded" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else case $host_os in darwin*) # FIXME - insert some real tests, host_os isn't really good enough striplib="$STRIP -x" old_striplib="$STRIP -S" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } ;; freebsd*) if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then old_striplib="$STRIP --strip-debug" striplib="$STRIP --strip-unneeded" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf '%s\n' "yes" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi ;; *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } ;; esac fi @@ -18897,12 +19064,12 @@ fi # Report what library types will actually be built - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 printf %s "checking if libtool supports shared libraries... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 -printf "%s\n" "$can_build_shared" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +printf '%s\n' "$can_build_shared" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 printf %s "checking whether to build shared libraries... " >&6; } test no = "$can_build_shared" && enable_shared=no @@ -18927,15 +19094,15 @@ printf %s "checking whether to build shared libraries... " >&6; } fi ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 -printf "%s\n" "$enable_shared" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +printf '%s\n' "$enable_shared" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 printf %s "checking whether to build static libraries... " >&6; } # Make sure either enable_shared or enable_static is yes. test yes = "$enable_shared" || enable_static=yes - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 -printf "%s\n" "$enable_static" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +printf '%s\n' "$enable_static" >&6; } @@ -18957,7 +19124,7 @@ ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 printf %s "checking how to run the C++ preprocessor... " >&6; } if test -z "$CXXCPP"; then if test ${ac_cv_prog_CXXCPP+y} @@ -19024,8 +19191,8 @@ fi else ac_cv_prog_CXXCPP=$CXXCPP fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 -printf "%s\n" "$CXXCPP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +printf '%s\n' "$CXXCPP" >&6; } ac_preproc_ok=false for ac_cxx_preproc_warn_flag in '' yes do @@ -19073,8 +19240,8 @@ if $ac_preproc_ok then : else case e in @%:@( - e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check See 'config.log' for more details" "$LINENO" 5; } ;; esac @@ -19222,7 +19389,7 @@ fi ac_prog=ld if test yes = "$GCC"; then # Check if gcc -print-prog-name=ld gives a path. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 printf %s "checking for ld used by $CC... " >&6; } case $host in *-*-mingw* | *-*-windows*) @@ -19252,10 +19419,10 @@ printf %s "checking for ld used by $CC... " >&6; } ;; esac elif test yes = "$with_gnu_ld"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 printf %s "checking for GNU ld... " >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 printf %s "checking for non-GNU ld... " >&6; } fi if test ${lt_cv_path_LD+y} @@ -19291,14 +19458,14 @@ fi LD=$lt_cv_path_LD if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -printf "%s\n" "$LD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +printf '%s\n' "$LD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${lt_cv_prog_gnu_ld+y} then : @@ -19315,8 +19482,8 @@ case `$LD -v 2>&1 &5 -printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5 +printf '%s\n' "$lt_cv_prog_gnu_ld" >&6; } with_gnu_ld=$lt_cv_prog_gnu_ld @@ -19369,7 +19536,7 @@ with_gnu_ld=$lt_cv_prog_gnu_ld fi # PORTME: fill in a description of your system's C++ link characteristics - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } ld_shlibs_CXX=yes case $host_os in @@ -20461,8 +20628,8 @@ fi ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 -printf "%s\n" "$ld_shlibs_CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +printf '%s\n' "$ld_shlibs_CXX" >&6; } test no = "$ld_shlibs_CXX" && can_build_shared=no GCC_CXX=$GXX @@ -20500,7 +20667,7 @@ esac if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then # Parse the compiler output and extract the necessary # objects, libraries and library flags. @@ -20988,7 +21155,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic_CXX+y} then : @@ -20997,15 +21164,15 @@ else case e in @%:@( e) lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_CXX" >&6; } lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } if test ${lt_cv_prog_compiler_pic_works_CXX+y} then : @@ -21042,8 +21209,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works_CXX" >&6; } if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then case $lt_prog_compiler_pic_CXX in @@ -21065,7 +21232,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works_CXX+y} then : @@ -21095,8 +21262,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works_CXX" >&6; } if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then : @@ -21107,7 +21274,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o_CXX+y} then : @@ -21156,12 +21323,12 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o_CXX" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o_CXX+y} then : @@ -21210,8 +21377,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_c_o_CXX" >&6; } @@ -21219,7 +21386,7 @@ printf "%s\n" "$lt_cv_prog_compiler_c_o_CXX" >&6; } hard_links=nottested if test no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; then # do not overwrite the value of need_locks provided by the user - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 printf %s "checking if we can lock with hard links... " >&6; } hard_links=yes $RM conftest* @@ -21227,11 +21394,11 @@ printf %s "checking if we can lock with hard links... " >&6; } touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 -printf "%s\n" "$hard_links" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +printf '%s\n' "$hard_links" >&6; } if test no = "$hard_links"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5 -printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5 +printf '%s\n' "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;} need_locks=warn fi else @@ -21240,7 +21407,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' @@ -21280,8 +21447,8 @@ printf %s "checking whether the $compiler linker ($LD) supports shared libraries ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 -printf "%s\n" "$ld_shlibs_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +printf '%s\n' "$ld_shlibs_CXX" >&6; } test no = "$ld_shlibs_CXX" && can_build_shared=no with_gnu_ld_CXX=$with_gnu_ld @@ -21308,7 +21475,7 @@ x|xyes) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 printf %s "checking whether -lc should be explicitly linked in... " >&6; } if test ${lt_cv_archive_cmds_need_lc_CXX+y} then : @@ -21320,7 +21487,7 @@ else case e in @%:@( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } 2>conftest.err; then soname=conftest lib=conftest @@ -21338,7 +21505,7 @@ else case e in @%:@( if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then lt_cv_archive_cmds_need_lc_CXX=no @@ -21353,8 +21520,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 -printf "%s\n" "$lt_cv_archive_cmds_need_lc_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 +printf '%s\n' "$lt_cv_archive_cmds_need_lc_CXX" >&6; } archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX ;; esac @@ -21423,7 +21590,7 @@ esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 printf %s "checking dynamic linker characteristics... " >&6; } library_names_spec= @@ -22602,7 +22769,7 @@ case $host_os in ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic_CXX+y} then : @@ -22611,15 +22778,15 @@ else case e in @%:@( e) lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_CXX" >&6; } lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX # # Check to make sure the PIC flag actually works. # if test -n "$lt_prog_compiler_pic_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } if test ${lt_cv_prog_compiler_pic_works_CXX+y} then : @@ -22656,8 +22823,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_pic_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_pic_works_CXX" >&6; } if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then case $lt_prog_compiler_pic_CXX in @@ -22679,7 +22846,7 @@ fi # Check to make sure the static flag actually works. # wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } if test ${lt_cv_prog_compiler_static_works_CXX+y} then : @@ -22709,8 +22876,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 -printf "%s\n" "$lt_cv_prog_compiler_static_works_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +printf '%s\n' "$lt_cv_prog_compiler_static_works_CXX" >&6; } if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then : @@ -22731,8 +22898,8 @@ fi dynamic_linker=no ;; esac -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 -printf "%s\n" "$dynamic_linker" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +printf '%s\n' "$dynamic_linker" >&6; } test no = "$dynamic_linker" && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" @@ -22796,7 +22963,7 @@ configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 printf %s "checking how to hardcode library paths into programs... " >&6; } hardcode_action_CXX= if test -n "$hardcode_libdir_flag_spec_CXX" || @@ -22821,8 +22988,8 @@ else # directories. hardcode_action_CXX=unsupported fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 -printf "%s\n" "$hardcode_action_CXX" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +printf '%s\n' "$hardcode_action_CXX" >&6; } if test relink = "$hardcode_action_CXX" || test yes = "$inherit_rpath_CXX"; then @@ -22886,7 +23053,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}windres", so it can be a program name with args. set dummy ${ac_tool_prefix}windres; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_RC+y} then : @@ -22907,7 +23074,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RC="${ac_tool_prefix}windres" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -22919,11 +23086,11 @@ esac fi RC=$ac_cv_prog_RC if test -n "$RC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RC" >&5 -printf "%s\n" "$RC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RC" >&5 +printf '%s\n' "$RC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -22932,7 +23099,7 @@ if test -z "$ac_cv_prog_RC"; then ac_ct_RC=$RC # Extract the first word of "windres", so it can be a program name with args. set dummy windres; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_RC+y} then : @@ -22953,7 +23120,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_RC="windres" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -22965,11 +23132,11 @@ esac fi ac_ct_RC=$ac_cv_prog_ac_ct_RC if test -n "$ac_ct_RC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RC" >&5 -printf "%s\n" "$ac_ct_RC" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RC" >&5 +printf '%s\n' "$ac_ct_RC" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_RC" = x; then @@ -22977,8 +23144,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac RC=$ac_ct_RC @@ -23082,7 +23249,7 @@ if test $is_woe32 = yes; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}windres", so it can be a program name with args. set dummy ${ac_tool_prefix}windres; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_WINDRES+y} then : @@ -23103,7 +23270,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_WINDRES="${ac_tool_prefix}windres" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -23115,11 +23282,11 @@ esac fi WINDRES=$ac_cv_prog_WINDRES if test -n "$WINDRES"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WINDRES" >&5 -printf "%s\n" "$WINDRES" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $WINDRES" >&5 +printf '%s\n' "$WINDRES" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -23128,7 +23295,7 @@ if test -z "$ac_cv_prog_WINDRES"; then ac_ct_WINDRES=$WINDRES # Extract the first word of "windres", so it can be a program name with args. set dummy windres; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_WINDRES+y} then : @@ -23149,7 +23316,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_WINDRES="windres" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -23161,11 +23328,11 @@ esac fi ac_ct_WINDRES=$ac_cv_prog_ac_ct_WINDRES if test -n "$ac_ct_WINDRES"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_WINDRES" >&5 -printf "%s\n" "$ac_ct_WINDRES" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_WINDRES" >&5 +printf '%s\n' "$ac_ct_WINDRES" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi if test "x$ac_ct_WINDRES" = x; then @@ -23173,8 +23340,8 @@ fi else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac WINDRES=$ac_ct_WINDRES @@ -23200,7 +23367,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether NLS is requested" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether NLS is requested" >&5 printf %s "checking whether NLS is requested... " >&6; } @%:@ Check whether --enable-nls was given. if test ${enable_nls+y} @@ -23211,8 +23378,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5 -printf "%s\n" "$USE_NLS" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5 +printf '%s\n' "$USE_NLS" >&6; } @@ -23251,7 +23418,7 @@ rm -f conf$$.file # Extract the first word of "msgfmt", so it can be a program name with args. set dummy msgfmt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_MSGFMT+y} then : @@ -23285,16 +23452,16 @@ esac fi MSGFMT="$ac_cv_path_MSGFMT" if test "$MSGFMT" != ":"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5 -printf "%s\n" "$MSGFMT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5 +printf '%s\n' "$MSGFMT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi # Extract the first word of "gmsgfmt", so it can be a program name with args. set dummy gmsgfmt; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_GMSGFMT+y} then : @@ -23317,7 +23484,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_GMSGFMT="$as_dir$ac_word$ac_exec_ext" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -23331,11 +23498,11 @@ esac fi GMSGFMT=$ac_cv_path_GMSGFMT if test -n "$GMSGFMT"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GMSGFMT" >&5 -printf "%s\n" "$GMSGFMT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $GMSGFMT" >&5 +printf '%s\n' "$GMSGFMT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -23376,7 +23543,7 @@ rm -f conf$$.file # Extract the first word of "xgettext", so it can be a program name with args. set dummy xgettext; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_XGETTEXT+y} then : @@ -23410,11 +23577,11 @@ esac fi XGETTEXT="$ac_cv_path_XGETTEXT" if test "$XGETTEXT" != ":"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XGETTEXT" >&5 -printf "%s\n" "$XGETTEXT" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $XGETTEXT" >&5 +printf '%s\n' "$XGETTEXT" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi rm -f messages.po @@ -23455,7 +23622,7 @@ rm -f conf$$.file # Extract the first word of "msgmerge", so it can be a program name with args. set dummy msgmerge; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_MSGMERGE+y} then : @@ -23488,11 +23655,11 @@ esac fi MSGMERGE="$ac_cv_path_MSGMERGE" if test "$MSGMERGE" != ":"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSGMERGE" >&5 -printf "%s\n" "$MSGMERGE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MSGMERGE" >&5 +printf '%s\n' "$MSGMERGE" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -23554,16 +23721,16 @@ if test "${PATH_SEPARATOR+set}" != set; then fi if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld" >&5 printf %s "checking for ld... " >&6; } elif test "$GCC" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 printf %s "checking for ld used by $CC... " >&6; } elif test "$with_gnu_ld" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 printf %s "checking for GNU ld... " >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 printf %s "checking for non-GNU ld... " >&6; } fi if test -n "$LD"; then @@ -23687,14 +23854,14 @@ fi LD="$acl_cv_path_LD" fi if test -n "$LD"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 -printf "%s\n" "$LD" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5 +printf '%s\n' "$LD" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${acl_cv_prog_gnu_ld+y} then : @@ -23711,15 +23878,15 @@ case `$LD -v 2>&1 &5 -printf "%s\n" "$acl_cv_prog_gnu_ld" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_prog_gnu_ld" >&5 +printf '%s\n' "$acl_cv_prog_gnu_ld" >&6; } with_gnu_ld=$acl_cv_prog_gnu_ld - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shared library run path origin" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shared library run path origin" >&5 printf %s "checking for shared library run path origin... " >&6; } if test ${acl_cv_rpath+y} then : @@ -23734,8 +23901,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5 -printf "%s\n" "$acl_cv_rpath" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5 +printf '%s\n' "$acl_cv_rpath" >&6; } wl="$acl_cv_wl" acl_libext="$acl_cv_libext" acl_shlibext="$acl_cv_shlibext" @@ -23757,7 +23924,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking 32-bit host C ABI" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking 32-bit host C ABI" >&5 printf %s "checking 32-bit host C ABI... " >&6; } if test ${gl_cv_host_cpu_c_abi_32bit+y} then : @@ -23824,8 +23991,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_host_cpu_c_abi_32bit" >&5 -printf "%s\n" "$gl_cv_host_cpu_c_abi_32bit" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_host_cpu_c_abi_32bit" >&5 +printf '%s\n' "$gl_cv_host_cpu_c_abi_32bit" >&6; } HOST_CPU_C_ABI_32BIT="$gl_cv_host_cpu_c_abi_32bit" @@ -23833,7 +24000,7 @@ printf "%s\n" "$gl_cv_host_cpu_c_abi_32bit" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ELF binary format" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ELF binary format" >&5 printf %s "checking for ELF binary format... " >&6; } if test ${gl_cv_elf+y} then : @@ -23859,8 +24026,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_elf" >&5 -printf "%s\n" "$gl_cv_elf" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_elf" >&5 +printf '%s\n' "$gl_cv_elf" >&6; } if test $gl_cv_elf = yes; then # Extract the ELF class of a file (5th byte) in decimal. # Cf. https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header @@ -23911,7 +24078,7 @@ printf "%s\n" "$gl_cv_elf" >&6; } } fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the common suffixes of directories in the library search path" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for the common suffixes of directories in the library search path" >&5 printf %s "checking for the common suffixes of directories in the library search path... " >&6; } if test ${acl_cv_libdirstems+y} then : @@ -23988,8 +24155,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libdirstems" >&5 -printf "%s\n" "$acl_cv_libdirstems" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libdirstems" >&5 +printf '%s\n' "$acl_cv_libdirstems" >&6; } acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'` acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,//' -e 's/,.*//'` acl_libdirstem3=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,[^,]*,//' -e 's/,.*//'` @@ -24024,7 +24191,7 @@ printf "%s\n" "$acl_cv_libdirstems" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CFPreferencesCopyAppValue" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for CFPreferencesCopyAppValue" >&5 printf %s "checking for CFPreferencesCopyAppValue... " >&6; } if test ${gt_cv_func_CFPreferencesCopyAppValue+y} then : @@ -24055,14 +24222,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS="$gt_saved_LIBS" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5 -printf "%s\n" "$gt_cv_func_CFPreferencesCopyAppValue" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5 +printf '%s\n' "$gt_cv_func_CFPreferencesCopyAppValue" >&6; } if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then -printf "%s\n" "@%:@define HAVE_CFPREFERENCESCOPYAPPVALUE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_CFPREFERENCESCOPYAPPVALUE 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CFLocaleCopyPreferredLanguages" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for CFLocaleCopyPreferredLanguages" >&5 printf %s "checking for CFLocaleCopyPreferredLanguages... " >&6; } if test ${gt_cv_func_CFLocaleCopyPreferredLanguages+y} then : @@ -24093,11 +24260,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS="$gt_saved_LIBS" ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFLocaleCopyPreferredLanguages" >&5 -printf "%s\n" "$gt_cv_func_CFLocaleCopyPreferredLanguages" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFLocaleCopyPreferredLanguages" >&5 +printf '%s\n' "$gt_cv_func_CFLocaleCopyPreferredLanguages" >&6; } if test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then -printf "%s\n" "@%:@define HAVE_CFLOCALECOPYPREFERREDLANGUAGES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_CFLOCALECOPYPREFERREDLANGUAGES 1" >>confdefs.h fi INTL_MACOSX_LIBS= @@ -24128,7 +24295,7 @@ printf "%s\n" "@%:@define HAVE_CFLOCALECOPYPREFERREDLANGUAGES 1" >>confdefs.h if test "$USE_NLS" = "yes"; then gt_use_preinstalled_gnugettext=no - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether included gettext is requested" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether included gettext is requested" >&5 printf %s "checking whether included gettext is requested... " >&6; } @%:@ Check whether --with-included-gettext was given. @@ -24140,8 +24307,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $nls_cv_force_use_gnu_gettext" >&5 -printf "%s\n" "$nls_cv_force_use_gnu_gettext" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $nls_cv_force_use_gnu_gettext" >&5 +printf '%s\n' "$nls_cv_force_use_gnu_gettext" >&6; } nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" if test "$nls_cv_force_use_gnu_gettext" != "yes"; then @@ -24163,7 +24330,7 @@ typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; gt_expression_test_code= fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libc" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libc" >&5 printf %s "checking for GNU gettext in libc... " >&6; } if eval test \${$gt_func_gnugettext_libc+y} then : @@ -24205,8 +24372,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$gt_func_gnugettext_libc - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then @@ -24701,7 +24868,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libintl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libintl" >&5 printf %s "checking for GNU gettext in libintl... " >&6; } if eval test \${$gt_func_gnugettext_libintl+y} then : @@ -24799,8 +24966,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ esac fi eval ac_res=\$$gt_func_gnugettext_libintl - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } fi if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \ @@ -24846,19 +25013,19 @@ printf "%s\n" "$ac_res" >&6; } if test "$gt_use_preinstalled_gnugettext" = "yes" \ || test "$nls_cv_use_gnu_gettext" = "yes"; then -printf "%s\n" "@%:@define ENABLE_NLS 1" >>confdefs.h +printf '%s\n' "@%:@define ENABLE_NLS 1" >>confdefs.h else USE_NLS=no fi fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use NLS" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use NLS" >&5 printf %s "checking whether to use NLS... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5 -printf "%s\n" "$USE_NLS" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5 +printf '%s\n' "$USE_NLS" >&6; } if test "$USE_NLS" = "yes"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where the gettext function comes from" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking where the gettext function comes from" >&5 printf %s "checking where the gettext function comes from... " >&6; } if test "$gt_use_preinstalled_gnugettext" = "yes"; then if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then @@ -24869,18 +25036,18 @@ printf %s "checking where the gettext function comes from... " >&6; } else gt_source="included intl directory" fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_source" >&5 -printf "%s\n" "$gt_source" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_source" >&5 +printf '%s\n' "$gt_source" >&6; } fi if test "$USE_NLS" = "yes"; then if test "$gt_use_preinstalled_gnugettext" = "yes"; then if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libintl" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to link with libintl" >&5 printf %s "checking how to link with libintl... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBINTL" >&5 -printf "%s\n" "$LIBINTL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIBINTL" >&5 +printf '%s\n' "$LIBINTL" >&6; } for element in $INCINTL; do haveit= @@ -24907,10 +25074,10 @@ printf "%s\n" "$LIBINTL" >&6; } fi -printf "%s\n" "@%:@define HAVE_GETTEXT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_GETTEXT 1" >>confdefs.h -printf "%s\n" "@%:@define HAVE_DCGETTEXT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DCGETTEXT 1" >>confdefs.h fi @@ -24979,8 +25146,8 @@ printf "%s\n" "@%:@define HAVE_DCGETTEXT 1" >>confdefs.h if test ${enable_cross_guesses+y} then : enableval=$enable_cross_guesses; if test "x$enableval" != xconservative && test "x$enableval" != xrisky; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: invalid argument supplied to --enable-cross-guesses" >&5 -printf "%s\n" "$as_me: WARNING: invalid argument supplied to --enable-cross-guesses" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: invalid argument supplied to --enable-cross-guesses" >&5 +printf '%s\n' "$as_me: WARNING: invalid argument supplied to --enable-cross-guesses" >&2;} enableval=conservative fi gl_cross_guesses="$enableval" @@ -25006,14 +25173,14 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define size_t unsigned int" >>confdefs.h +printf '%s\n' "@%:@define size_t unsigned int" >>confdefs.h ;; esac fi # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5 printf %s "checking for working alloca.h... " >&6; } if test ${ac_cv_working_alloca_h+y} then : @@ -25042,15 +25209,15 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5 -printf "%s\n" "$ac_cv_working_alloca_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_working_alloca_h" >&5 +printf '%s\n' "$ac_cv_working_alloca_h" >&6; } if test $ac_cv_working_alloca_h = yes; then -printf "%s\n" "@%:@define HAVE_ALLOCA_H 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ALLOCA_H 1" >>confdefs.h fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for alloca" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for alloca" >&5 printf %s "checking for alloca... " >&6; } if test ${ac_cv_func_alloca_works+y} then : @@ -25095,12 +25262,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5 -printf "%s\n" "$ac_cv_func_alloca_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_alloca_works" >&5 +printf '%s\n' "$ac_cv_func_alloca_works" >&6; } if test $ac_cv_func_alloca_works = yes; then -printf "%s\n" "@%:@define HAVE_ALLOCA 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ALLOCA 1" >>confdefs.h else # The SVR3 libPW and SVR4 libucb both contain incompatible functions @@ -25114,10 +25281,10 @@ else ALLOCA=\${LIBOBJDIR}alloca.$ac_objext -printf "%s\n" "@%:@define C_ALLOCA 1" >>confdefs.h +printf '%s\n' "@%:@define C_ALLOCA 1" >>confdefs.h -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking stack direction for C alloca" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking stack direction for C alloca" >&5 printf %s "checking stack direction for C alloca... " >&6; } if test ${ac_cv_c_stack_direction+y} then : @@ -25161,16 +25328,16 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5 -printf "%s\n" "$ac_cv_c_stack_direction" >&6; } -printf "%s\n" "@%:@define STACK_DIRECTION $ac_cv_c_stack_direction" >>confdefs.h +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_stack_direction" >&5 +printf '%s\n' "$ac_cv_c_stack_direction" >&6; } +printf '%s\n' "@%:@define STACK_DIRECTION $ac_cv_c_stack_direction" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the preprocessor supports include_next" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the preprocessor supports include_next" >&5 printf %s "checking whether the preprocessor supports include_next... " >&6; } if test ${gl_cv_have_include_next+y} then : @@ -25235,8 +25402,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_include_next" >&5 -printf "%s\n" "$gl_cv_have_include_next" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_include_next" >&5 +printf '%s\n' "$gl_cv_have_include_next" >&6; } PRAGMA_SYSTEM_HEADER= if test $gl_cv_have_include_next = yes; then INCLUDE_NEXT=include_next @@ -25257,7 +25424,7 @@ printf "%s\n" "$gl_cv_have_include_next" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether source code line length is unlimited" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether source code line length is unlimited" >&5 printf %s "checking whether source code line length is unlimited... " >&6; } if test ${gl_cv_source_line_length_unlimited+y} then : @@ -25284,8 +25451,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_source_line_length_unlimited" >&5 -printf "%s\n" "$gl_cv_source_line_length_unlimited" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_source_line_length_unlimited" >&5 +printf '%s\n' "$gl_cv_source_line_length_unlimited" >&6; } if test $gl_cv_source_line_length_unlimited = no; then PRAGMA_COLUMNS="#pragma COLUMNS 10000" else @@ -25303,7 +25470,7 @@ printf "%s\n" "$gl_cv_source_line_length_unlimited" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether char8_t is correctly defined" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether char8_t is correctly defined" >&5 printf %s "checking whether char8_t is correctly defined... " >&6; } if test ${gl_cv_type_char8_t_works+y} then : @@ -25338,8 +25505,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char8_t_works" >&5 -printf "%s\n" "$gl_cv_type_char8_t_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char8_t_works" >&5 +printf '%s\n' "$gl_cv_type_char8_t_works" >&6; } if test $gl_cv_type_char8_t_works = no; then GNULIBHEADERS_OVERRIDE_CHAR8_T=1 else @@ -25348,7 +25515,7 @@ printf "%s\n" "$gl_cv_type_char8_t_works" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether char16_t is correctly defined" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether char16_t is correctly defined" >&5 printf %s "checking whether char16_t is correctly defined... " >&6; } if test ${gl_cv_type_char16_t_works+y} then : @@ -25385,8 +25552,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char16_t_works" >&5 -printf "%s\n" "$gl_cv_type_char16_t_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char16_t_works" >&5 +printf '%s\n' "$gl_cv_type_char16_t_works" >&6; } if test $gl_cv_type_char16_t_works = no; then GNULIBHEADERS_OVERRIDE_CHAR16_T=1 else @@ -25395,7 +25562,7 @@ printf "%s\n" "$gl_cv_type_char16_t_works" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether char32_t is correctly defined" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether char32_t is correctly defined" >&5 printf %s "checking whether char32_t is correctly defined... " >&6; } if test ${gl_cv_type_char32_t_works+y} then : @@ -25432,8 +25599,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char32_t_works" >&5 -printf "%s\n" "$gl_cv_type_char32_t_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_char32_t_works" >&5 +printf '%s\n' "$gl_cv_type_char32_t_works" >&6; } if test $gl_cv_type_char32_t_works = no; then GNULIBHEADERS_OVERRIDE_CHAR32_T=1 else @@ -25456,7 +25623,7 @@ printf "%s\n" "$gl_cv_type_char32_t_works" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_uchar_h='<'uchar.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_uchar_h+y} then : @@ -25507,8 +25674,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_uchar_h" >&5 -printf "%s\n" "$gl_cv_next_uchar_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_uchar_h" >&5 +printf '%s\n' "$gl_cv_next_uchar_h" >&6; } fi NEXT_UCHAR_H=$gl_cv_next_uchar_h @@ -25539,7 +25706,7 @@ printf "%s\n" "$gl_cv_next_uchar_h" >&6; } CXX_HAS_UCHAR_TYPES=0 if test $HAVE_UCHAR_H = 0; then if test "$CXX" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler predefines the types" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler predefines the types" >&5 printf %s "checking whether the C++ compiler predefines the types... " >&6; } if test ${gl_cv_cxx_has_uchar_types+y} then : @@ -25554,7 +25721,7 @@ EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$gl_command\""; } >&5 (eval $gl_command) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then gl_cv_cxx_has_uchar_types=yes else @@ -25564,8 +25731,8 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cxx_has_uchar_types" >&5 -printf "%s\n" "$gl_cv_cxx_has_uchar_types" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cxx_has_uchar_types" >&5 +printf '%s\n' "$gl_cv_cxx_has_uchar_types" >&6; } if test $gl_cv_cxx_has_uchar_types = yes; then CXX_HAS_UCHAR_TYPES=1 fi @@ -25575,7 +25742,7 @@ printf "%s\n" "$gl_cv_cxx_has_uchar_types" >&6; } CXX_HAS_CHAR8_TYPE=0 if test $HAVE_UCHAR_H = 0; then if test "$CXX" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler predefines the char8_t types" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler predefines the char8_t types" >&5 printf %s "checking whether the C++ compiler predefines the char8_t types... " >&6; } if test ${gl_cv_cxx_has_char8_type+y} then : @@ -25589,7 +25756,7 @@ EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$gl_command\""; } >&5 (eval $gl_command) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then gl_cv_cxx_has_char8_type=yes else @@ -25599,8 +25766,8 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cxx_has_char8_type" >&5 -printf "%s\n" "$gl_cv_cxx_has_char8_type" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cxx_has_char8_type" >&5 +printf '%s\n' "$gl_cv_cxx_has_char8_type" >&6; } if test $gl_cv_cxx_has_char8_type = yes; then CXX_HAS_CHAR8_TYPE=1 fi @@ -25611,7 +25778,7 @@ printf "%s\n" "$gl_cv_cxx_has_char8_type" >&6; } for gltype in wchar_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 printf %s "checking for bit size of $gltype... " >&6; } if eval test \${gl_cv_bitsizeof_${gltype}+y} then : @@ -25637,14 +25804,16 @@ fi esac fi eval ac_res=\$gl_cv_bitsizeof_${gltype} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval result=\$gl_cv_bitsizeof_${gltype} if test $result = unknown; then result=0 fi GLTYPE=`echo "$gltype" | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - printf "%s\n" "@%:@define BITSIZEOF_${GLTYPE} $result" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define BITSIZEOF_${GLTYPE} $result +_ACEOF eval BITSIZEOF_${GLTYPE}=\$result done @@ -25727,7 +25896,7 @@ printf "%s\n" "$ac_res" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for mbstate_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for mbstate_t" >&5 printf %s "checking for mbstate_t... " >&6; } if test ${ac_cv_type_mbstate_t+y} then : @@ -25755,15 +25924,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_mbstate_t" >&5 -printf "%s\n" "$ac_cv_type_mbstate_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_mbstate_t" >&5 +printf '%s\n' "$ac_cv_type_mbstate_t" >&6; } if test $ac_cv_type_mbstate_t = yes; then -printf "%s\n" "@%:@define HAVE_MBSTATE_T 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MBSTATE_T 1" >>confdefs.h else -printf "%s\n" "@%:@define mbstate_t int" >>confdefs.h +printf '%s\n' "@%:@define mbstate_t int" >>confdefs.h fi @@ -25782,7 +25951,7 @@ do done - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for nl_langinfo and CODESET" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for nl_langinfo and CODESET" >&5 printf %s "checking for nl_langinfo and CODESET... " >&6; } if test ${am_cv_langinfo_codeset+y} then : @@ -25811,18 +25980,18 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_langinfo_codeset" >&5 -printf "%s\n" "$am_cv_langinfo_codeset" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_langinfo_codeset" >&5 +printf '%s\n' "$am_cv_langinfo_codeset" >&6; } if test $am_cv_langinfo_codeset = yes; then -printf "%s\n" "@%:@define HAVE_LANGINFO_CODESET 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_LANGINFO_CODESET 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a traditional japanese locale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a traditional japanese locale" >&5 printf %s "checking for a traditional japanese locale... " >&6; } if test ${gt_cv_locale_ja+y} then : @@ -25905,7 +26074,7 @@ _ACEOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then case "$host_os" in # Handle native Windows specially, because there setlocale() interprets @@ -25964,13 +26133,13 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_ja" >&5 -printf "%s\n" "$gt_cv_locale_ja" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_ja" >&5 +printf '%s\n' "$gt_cv_locale_ja" >&6; } LOCALE_JA=$gt_cv_locale_ja case $LOCALE_JA in #( '' | *[[:space:]\"\$\'*@<:@]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_JA\"; assuming \"none\"" >&5 -printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_JA\"; assuming \"none\"" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_JA\"; assuming \"none\"" >&5 +printf '%s\n' "$as_me: WARNING: invalid locale \"$LOCALE_JA\"; assuming \"none\"" >&2;} LOCALE_JA=none;; esac @@ -25978,7 +26147,7 @@ printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_JA\"; assuming \"none\" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a french Unicode locale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a french Unicode locale" >&5 printf %s "checking for a french Unicode locale... " >&6; } if test ${gt_cv_locale_fr_utf8+y} then : @@ -26059,7 +26228,7 @@ _ACEOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then case "$host_os" in # Handle native Windows specially, because there setlocale() interprets @@ -26108,13 +26277,13 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fr_utf8" >&5 -printf "%s\n" "$gt_cv_locale_fr_utf8" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fr_utf8" >&5 +printf '%s\n' "$gt_cv_locale_fr_utf8" >&6; } LOCALE_FR_UTF8=$gt_cv_locale_fr_utf8 case $LOCALE_FR_UTF8 in #( '' | *[[:space:]\"\$\'*@<:@]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_FR_UTF8\"; assuming \"none\"" >&5 -printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_FR_UTF8\"; assuming \"none\"" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_FR_UTF8\"; assuming \"none\"" >&5 +printf '%s\n' "$as_me: WARNING: invalid locale \"$LOCALE_FR_UTF8\"; assuming \"none\"" >&2;} LOCALE_FR_UTF8=none;; esac @@ -26141,7 +26310,7 @@ printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_FR_UTF8\"; assuming \"n - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a transitional chinese locale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a transitional chinese locale" >&5 printf %s "checking for a transitional chinese locale... " >&6; } if test ${gt_cv_locale_zh_CN+y} then : @@ -26225,7 +26394,7 @@ _ACEOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then case "$host_os" in # Handle native Windows specially, because there setlocale() interprets @@ -26277,13 +26446,13 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_zh_CN" >&5 -printf "%s\n" "$gt_cv_locale_zh_CN" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_zh_CN" >&5 +printf '%s\n' "$gt_cv_locale_zh_CN" >&6; } LOCALE_ZH_CN=$gt_cv_locale_zh_CN case $LOCALE_ZH_CN in #( '' | *[[:space:]\"\$\'*@<:@]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_ZH_CN\"; assuming \"none\"" >&5 -printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_ZH_CN\"; assuming \"none\"" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_ZH_CN\"; assuming \"none\"" >&5 +printf '%s\n' "$as_me: WARNING: invalid locale \"$LOCALE_ZH_CN\"; assuming \"none\"" >&2;} LOCALE_ZH_CN=none;; esac @@ -26304,7 +26473,7 @@ printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_ZH_CN\"; assuming \"non - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles incomplete characters" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles incomplete characters" >&5 printf %s "checking whether mbrtowc handles incomplete characters... " >&6; } if test ${gl_cv_func_mbrtowc_incomplete_state+y} then : @@ -26401,13 +26570,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_incomplete_state" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_incomplete_state" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_incomplete_state" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_incomplete_state" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc works as well as mbtowc" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc works as well as mbtowc" >&5 printf %s "checking whether mbrtowc works as well as mbtowc... " >&6; } if test ${gl_cv_func_mbrtowc_sanitycheck+y} then : @@ -26467,8 +26636,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_sanitycheck" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_sanitycheck" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_sanitycheck" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_sanitycheck" >&6; } REPLACE_MBSTATE_T=0 case "$gl_cv_func_mbrtowc_incomplete_state" in @@ -26483,8 +26652,8 @@ printf "%s\n" "$gl_cv_func_mbrtowc_sanitycheck" >&6; } REPLACE_MBSTATE_T=1 fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5 -printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to detect undeclared functions" >&5 +printf %s "checking for $CC options to detect undeclared functions... " >&6; } if test ${ac_cv_c_undeclared_builtin_options+y} then : printf %s "(cached) " >&6 @@ -26552,12 +26721,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5 -printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5 +printf '%s\n' "$ac_cv_c_undeclared_builtin_options" >&6; } case $ac_cv_c_undeclared_builtin_options in @%:@( 'cannot detect') : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot make $CC report undeclared builtins See 'config.log' for more details" "$LINENO" 5; } ;; @%:@( 'none needed') : @@ -26566,19 +26735,62 @@ See 'config.log' for more details" "$LINENO" 5; } ;; @%:@( ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; esac +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to ignore future-version functions" >&5 +printf %s "checking for $CC options to ignore future-version functions... " >&6; } +if test ${ac_cv_c_future_darwin_options+y} +then : + printf %s "(cached) " >&6 +else case e in @%:@( + e) ac_compile_saved="$ac_compile" + ac_compile="$ac_compile -Werror=unguarded-availability-new" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#if ! (defined __APPLE__ && defined __MACH__) + #error "-Werror=unguarded-availability-new not needed here" + #endif + +int +main (void) +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_c_future_darwin_options='-Werror=unguarded-availability-new' +else case e in @%:@( + e) ac_cv_c_future_darwin_options='none needed' ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_compile="$ac_compile_saved" + ;; +esac +fi +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_future_darwin_options" >&5 +printf '%s\n' "$ac_cv_c_future_darwin_options" >&6; } + case $ac_cv_c_future_darwin_options in @%:@( + 'none needed') : + ac_c_future_darwin_options='' ;; @%:@( + *) : + ac_c_future_darwin_options=$ac_cv_c_future_darwin_options ;; +esac + ac_fn_check_decl "$LINENO" "mbrtoc32" "ac_cv_have_decl_mbrtoc32" "#ifdef __HAIKU__ #include #endif #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_mbrtoc32" = xyes then : fi if test $ac_cv_have_decl_mbrtoc32 = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for mbrtoc32" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for mbrtoc32" >&5 printf %s "checking for mbrtoc32... " >&6; } if test ${gl_cv_func_mbrtoc32+y} then : @@ -26615,8 +26827,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32" >&5 -printf "%s\n" "$gl_cv_func_mbrtoc32" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32" >&5 +printf '%s\n' "$gl_cv_func_mbrtoc32" >&6; } else gl_cv_func_mbrtoc32=no fi @@ -26624,7 +26836,7 @@ printf "%s\n" "$gl_cv_func_mbrtoc32" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a traditional french locale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a traditional french locale" >&5 printf %s "checking for a traditional french locale... " >&6; } if test ${gt_cv_locale_fr+y} then : @@ -26703,7 +26915,7 @@ _ACEOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then case "$host_os" in # Handle native Windows specially, because there setlocale() interprets @@ -26760,13 +26972,13 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fr" >&5 -printf "%s\n" "$gt_cv_locale_fr" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fr" >&5 +printf '%s\n' "$gt_cv_locale_fr" >&6; } LOCALE_FR=$gt_cv_locale_fr case $LOCALE_FR in #( '' | *[[:space:]\"\$\'*@<:@]*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_FR\"; assuming \"none\"" >&5 -printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_FR\"; assuming \"none\"" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: invalid locale \"$LOCALE_FR\"; assuming \"none\"" >&5 +printf '%s\n' "$as_me: WARNING: invalid locale \"$LOCALE_FR\"; assuming \"none\"" >&2;} LOCALE_FR=none;; esac @@ -26780,7 +26992,7 @@ printf "%s\n" "$as_me: WARNING: invalid locale \"$LOCALE_FR\"; assuming \"none\" if test $GNULIBHEADERS_OVERRIDE_CHAR32_T = 1 || test $gl_cv_func_mbrtoc32 = no; then HAVE_WORKING_MBRTOC32=0 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtoc32 works as well as mbrtowc" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtoc32 works as well as mbrtowc" >&5 printf %s "checking whether mbrtoc32 works as well as mbrtowc... " >&6; } if test ${gl_cv_func_mbrtoc32_sanitycheck+y} then : @@ -26869,13 +27081,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_sanitycheck" >&5 -printf "%s\n" "$gl_cv_func_mbrtoc32_sanitycheck" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_sanitycheck" >&5 +printf '%s\n' "$gl_cv_func_mbrtoc32_sanitycheck" >&6; } case "$gl_cv_func_mbrtoc32_sanitycheck" in *yes) HAVE_WORKING_MBRTOC32=1 -printf "%s\n" "@%:@define HAVE_WORKING_MBRTOC32 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WORKING_MBRTOC32 1" >>confdefs.h ;; *) HAVE_WORKING_MBRTOC32=0 ;; @@ -27099,7 +27311,7 @@ printf "%s\n" "@%:@define HAVE_WORKING_MBRTOC32 1" >>confdefs.h REPLACE_WCTOMB=0; - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether malloc is ptrdiff_t safe" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether malloc is ptrdiff_t safe" >&5 printf %s "checking whether malloc is ptrdiff_t safe... " >&6; } if test ${gl_cv_malloc_ptrdiff+y} then : @@ -27147,8 +27359,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_malloc_ptrdiff" >&5 -printf "%s\n" "$gl_cv_malloc_ptrdiff" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_malloc_ptrdiff" >&5 +printf '%s\n' "$gl_cv_malloc_ptrdiff" >&6; } @@ -27157,7 +27369,7 @@ printf "%s\n" "$gl_cv_malloc_ptrdiff" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether malloc, realloc, calloc set errno on failure" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether malloc, realloc, calloc set errno on failure" >&5 printf %s "checking whether malloc, realloc, calloc set errno on failure... " >&6; } if test ${gl_cv_func_malloc_posix+y} then : @@ -27176,8 +27388,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_malloc_posix" >&5 -printf "%s\n" "$gl_cv_func_malloc_posix" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_malloc_posix" >&5 +printf '%s\n' "$gl_cv_func_malloc_posix" >&6; } @@ -27185,7 +27397,7 @@ printf "%s\n" "$gl_cv_func_malloc_posix" >&6; } if test "$gl_cv_func_malloc_posix" = yes; then -printf "%s\n" "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h else REPLACE_MALLOC_FOR_MALLOC_POSIX=1 @@ -27405,7 +27617,7 @@ printf "%s\n" "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether lstat correctly handles trailing slash" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether lstat correctly handles trailing slash" >&5 printf %s "checking whether lstat correctly handles trailing slash... " >&6; } if test ${gl_cv_func_lstat_dereferences_slashed_symlink+y} then : @@ -27468,12 +27680,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_lstat_dereferences_slashed_symlink" >&5 -printf "%s\n" "$gl_cv_func_lstat_dereferences_slashed_symlink" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_lstat_dereferences_slashed_symlink" >&5 +printf '%s\n' "$gl_cv_func_lstat_dereferences_slashed_symlink" >&6; } case "$gl_cv_func_lstat_dereferences_slashed_symlink" in *yes) -printf "%s\n" "@%:@define LSTAT_FOLLOWS_SLASHED_SYMLINK 1" >>confdefs.h +printf '%s\n' "@%:@define LSTAT_FOLLOWS_SLASHED_SYMLINK 1" >>confdefs.h ;; esac @@ -27481,7 +27693,7 @@ printf "%s\n" "@%:@define LSTAT_FOLLOWS_SLASHED_SYMLINK 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether // is distinct from /" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether // is distinct from /" >&5 printf %s "checking whether // is distinct from /... " >&6; } if test ${gl_cv_double_slash_root+y} then : @@ -27512,11 +27724,11 @@ else case e in @%:@( fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_double_slash_root" >&5 -printf "%s\n" "$gl_cv_double_slash_root" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_double_slash_root" >&5 +printf '%s\n' "$gl_cv_double_slash_root" >&6; } if test "$gl_cv_double_slash_root" = yes; then -printf "%s\n" "@%:@define DOUBLE_SLASH_IS_DISTINCT_ROOT 1" >>confdefs.h +printf '%s\n' "@%:@define DOUBLE_SLASH_IS_DISTINCT_ROOT 1" >>confdefs.h fi @@ -27524,7 +27736,7 @@ printf "%s\n" "@%:@define DOUBLE_SLASH_IS_DISTINCT_ROOT 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether realpath works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether realpath works" >&5 printf %s "checking whether realpath works... " >&6; } if test ${gl_cv_func_realpath_works+y} then : @@ -27758,17 +27970,17 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_realpath_works" >&5 -printf "%s\n" "$gl_cv_func_realpath_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_realpath_works" >&5 +printf '%s\n' "$gl_cv_func_realpath_works" >&6; } case "$gl_cv_func_realpath_works" in *yes) -printf "%s\n" "@%:@define FUNC_REALPATH_WORKS 1" >>confdefs.h +printf '%s\n' "@%:@define FUNC_REALPATH_WORKS 1" >>confdefs.h ;; *nearly) -printf "%s\n" "@%:@define FUNC_REALPATH_NEARLY_WORKS 1" >>confdefs.h +printf '%s\n' "@%:@define FUNC_REALPATH_NEARLY_WORKS 1" >>confdefs.h ;; esac @@ -27780,7 +27992,7 @@ printf "%s\n" "@%:@define FUNC_REALPATH_NEARLY_WORKS 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for faccessat" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for faccessat" >&5 printf %s "checking for faccessat... " >&6; } if test ${gl_cv_onwards_func_faccessat+y} then : @@ -27793,7 +28005,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "faccessat" "ac_cv_have_decl_faccessat" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_faccessat" = xyes then : @@ -27833,8 +28045,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_faccessat" >&5 -printf "%s\n" "$gl_cv_onwards_func_faccessat" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_faccessat" >&5 +printf '%s\n' "$gl_cv_onwards_func_faccessat" >&6; } case "$gl_cv_onwards_func_faccessat" in future*) ac_cv_func_faccessat=no ;; @@ -27842,7 +28054,7 @@ printf "%s\n" "$gl_cv_onwards_func_faccessat" >&6; } esac if test $ac_cv_func_faccessat = yes; then -printf "%s\n" "@%:@define HAVE_FACCESSAT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FACCESSAT 1" >>confdefs.h fi @@ -27854,7 +28066,7 @@ printf "%s\n" "@%:@define HAVE_FACCESSAT 1" >>confdefs.h *) ac_fn_c_check_func "$LINENO" "getcwd" "ac_cv_func_getcwd" if test "x$ac_cv_func_getcwd" = xyes then : - printf "%s\n" "@%:@define HAVE_GETCWD 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_GETCWD 1" >>confdefs.h fi ;; @@ -27864,7 +28076,7 @@ fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C/C++ restrict keyword" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C/C++ restrict keyword" >&5 printf %s "checking for C/C++ restrict keyword... " >&6; } if test ${ac_cv_c_restrict+y} then : @@ -27904,14 +28116,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_restrict" >&5 -printf "%s\n" "$ac_cv_c_restrict" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_restrict" >&5 +printf '%s\n' "$ac_cv_c_restrict" >&6; } case $ac_cv_c_restrict in restrict) ;; - no) printf "%s\n" "@%:@define restrict /**/" >>confdefs.h + no) printf '%s\n' "@%:@define restrict /**/" >>confdefs.h ;; - *) printf "%s\n" "@%:@define restrict $ac_cv_c_restrict" >>confdefs.h + *) printf '%s\n' "@%:@define restrict $ac_cv_c_restrict" >>confdefs.h ;; esac @@ -28025,7 +28237,7 @@ printf "%s\n" "$ac_cv_c_restrict" >&6; } if test $ac_cv_func__set_invalid_parameter_handler = yes; then HAVE_MSVC_INVALID_PARAMETER_HANDLER=1 -printf "%s\n" "@%:@define HAVE_MSVC_INVALID_PARAMETER_HANDLER 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MSVC_INVALID_PARAMETER_HANDLER 1" >>confdefs.h else HAVE_MSVC_INVALID_PARAMETER_HANDLER=0 @@ -28050,7 +28262,7 @@ printf "%s\n" "@%:@define HAVE_MSVC_INVALID_PARAMETER_HANDLER 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default" if test "x$ac_cv_header_winsock2_h" = xyes then : - printf "%s\n" "@%:@define HAVE_WINSOCK2_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_WINSOCK2_H 1" >>confdefs.h fi @@ -28470,7 +28682,7 @@ gl_mda_defines=' - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if environ is properly declared" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if environ is properly declared" >&5 printf %s "checking if environ is properly declared... " >&6; } if test ${gt_cv_var_environ_declaration+y} then : @@ -28504,11 +28716,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_var_environ_declaration" >&5 -printf "%s\n" "$gt_cv_var_environ_declaration" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_var_environ_declaration" >&5 +printf '%s\n' "$gt_cv_var_environ_declaration" >&6; } if test $gt_cv_var_environ_declaration = yes; then -printf "%s\n" "@%:@define HAVE_ENVIRON_DECL 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ENVIRON_DECL 1" >>confdefs.h fi @@ -28519,7 +28731,7 @@ printf "%s\n" "@%:@define HAVE_ENVIRON_DECL 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for complete errno.h" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for complete errno.h" >&5 printf %s "checking for complete errno.h... " >&6; } if test ${gl_cv_header_errno_h_complete+y} then : @@ -28596,8 +28808,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_complete" >&5 -printf "%s\n" "$gl_cv_header_errno_h_complete" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_complete" >&5 +printf '%s\n' "$gl_cv_header_errno_h_complete" >&6; } if test $gl_cv_header_errno_h_complete = yes; then GL_GENERATE_ERRNO_H=false else @@ -28612,7 +28824,7 @@ printf "%s\n" "$gl_cv_header_errno_h_complete" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_errno_h='<'errno.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_errno_h+y} then : @@ -28657,8 +28869,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_errno_h" >&5 -printf "%s\n" "$gl_cv_next_errno_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_errno_h" >&5 +printf '%s\n' "$gl_cv_next_errno_h" >&6; } fi NEXT_ERRNO_H=$gl_cv_next_errno_h @@ -28678,7 +28890,7 @@ printf "%s\n" "$gl_cv_next_errno_h" >&6; } fi if $GL_GENERATE_ERRNO_H; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EMULTIHOP value" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for EMULTIHOP value" >&5 printf %s "checking for EMULTIHOP value... " >&6; } if test ${gl_cv_header_errno_h_EMULTIHOP+y} then : @@ -28739,8 +28951,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_EMULTIHOP" >&5 -printf "%s\n" "$gl_cv_header_errno_h_EMULTIHOP" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_EMULTIHOP" >&5 +printf '%s\n' "$gl_cv_header_errno_h_EMULTIHOP" >&6; } case $gl_cv_header_errno_h_EMULTIHOP in yes | no) EMULTIHOP_HIDDEN=0; EMULTIHOP_VALUE= @@ -28755,7 +28967,7 @@ printf "%s\n" "$gl_cv_header_errno_h_EMULTIHOP" >&6; } if $GL_GENERATE_ERRNO_H; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ENOLINK value" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ENOLINK value" >&5 printf %s "checking for ENOLINK value... " >&6; } if test ${gl_cv_header_errno_h_ENOLINK+y} then : @@ -28816,8 +29028,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_ENOLINK" >&5 -printf "%s\n" "$gl_cv_header_errno_h_ENOLINK" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_ENOLINK" >&5 +printf '%s\n' "$gl_cv_header_errno_h_ENOLINK" >&6; } case $gl_cv_header_errno_h_ENOLINK in yes | no) ENOLINK_HIDDEN=0; ENOLINK_VALUE= @@ -28832,7 +29044,7 @@ printf "%s\n" "$gl_cv_header_errno_h_ENOLINK" >&6; } if $GL_GENERATE_ERRNO_H; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EOVERFLOW value" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for EOVERFLOW value" >&5 printf %s "checking for EOVERFLOW value... " >&6; } if test ${gl_cv_header_errno_h_EOVERFLOW+y} then : @@ -28893,8 +29105,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_EOVERFLOW" >&5 -printf "%s\n" "$gl_cv_header_errno_h_EOVERFLOW" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_errno_h_EOVERFLOW" >&5 +printf '%s\n' "$gl_cv_header_errno_h_EOVERFLOW" >&6; } case $gl_cv_header_errno_h_EOVERFLOW in yes | no) EOVERFLOW_HIDDEN=0; EOVERFLOW_VALUE= @@ -28923,7 +29135,7 @@ printf "%s\n" "$gl_cv_header_errno_h_EOVERFLOW" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_error_h='<'error.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_error_h+y} then : @@ -28974,8 +29186,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_error_h" >&5 -printf "%s\n" "$gl_cv_next_error_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_error_h" >&5 +printf '%s\n' "$gl_cv_next_error_h" >&6; } fi NEXT_ERROR_H=$gl_cv_next_error_h @@ -29002,7 +29214,7 @@ printf "%s\n" "$gl_cv_next_error_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for error" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for error" >&5 printf %s "checking for error... " >&6; } if test ${gl_cv_onwards_func_error+y} then : @@ -29015,7 +29227,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "error" "ac_cv_have_decl_error" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_error" = xyes then : @@ -29055,8 +29267,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_error" >&5 -printf "%s\n" "$gl_cv_onwards_func_error" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_error" >&5 +printf '%s\n' "$gl_cv_onwards_func_error" >&6; } case "$gl_cv_onwards_func_error" in future*) ac_cv_func_error=no ;; @@ -29064,7 +29276,7 @@ printf "%s\n" "$gl_cv_onwards_func_error" >&6; } esac if test $ac_cv_func_error = yes; then -printf "%s\n" "@%:@define HAVE_ERROR 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ERROR 1" >>confdefs.h fi @@ -29079,13 +29291,13 @@ printf "%s\n" "@%:@define HAVE_ERROR 1" >>confdefs.h fi ac_fn_check_decl "$LINENO" "error_at_line" "ac_cv_have_decl_error_at_line" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_error_at_line" = xyes then : fi if test $ac_cv_have_decl_error_at_line = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for error_at_line" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for error_at_line" >&5 printf %s "checking for error_at_line... " >&6; } if test ${ac_cv_lib_error_at_line+y} then : @@ -29113,8 +29325,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_error_at_line" >&5 -printf "%s\n" "$ac_cv_lib_error_at_line" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_error_at_line" >&5 +printf '%s\n' "$ac_cv_lib_error_at_line" >&6; } else ac_cv_lib_error_at_line=no fi @@ -29126,7 +29338,7 @@ printf "%s\n" "$ac_cv_lib_error_at_line" >&6; } REPLACE_ERROR_AT_LINE=0 if test $ac_cv_func_error = yes && test $ac_cv_lib_error_at_line = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working error function" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working error function" >&5 printf %s "checking for working error function... " >&6; } if test ${gl_cv_func_working_error+y} then : @@ -29209,8 +29421,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_working_error" >&5 -printf "%s\n" "$gl_cv_func_working_error" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_working_error" >&5 +printf '%s\n' "$gl_cv_func_working_error" >&6; } case "$gl_cv_func_working_error" in *no) REPLACE_ERROR=1 @@ -29231,7 +29443,7 @@ printf "%s\n" "$gl_cv_func_working_error" >&6; } -ac_fn_check_decl "$LINENO" "strerror_r" "ac_cv_have_decl_strerror_r" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "strerror_r" "ac_cv_have_decl_strerror_r" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_strerror_r" = xyes then : ac_have_decl=1 @@ -29239,7 +29451,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_STRERROR_R $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_STRERROR_R $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_strerror_r = yes; then @@ -29247,11 +29459,11 @@ if test $ac_cv_have_decl_strerror_r = yes; then # (We used to run AC_CHECK_FUNCS_ONCE for strerror_r, as well # as AC_CHECK_DECLS_ONCE.) -printf "%s\n" "@%:@define HAVE_STRERROR_R 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRERROR_R 1" >>confdefs.h fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether strerror_r returns char *" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether strerror_r returns char *" >&5 printf %s "checking whether strerror_r returns char *... " >&6; } if test ${ac_cv_func_strerror_r_char_p+y} then : @@ -29286,11 +29498,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strerror_r_char_p" >&5 -printf "%s\n" "$ac_cv_func_strerror_r_char_p" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strerror_r_char_p" >&5 +printf '%s\n' "$ac_cv_func_strerror_r_char_p" >&6; } if test $ac_cv_func_strerror_r_char_p = yes; then -printf "%s\n" "@%:@define STRERROR_R_CHAR_P 1" >>confdefs.h +printf '%s\n' "@%:@define STRERROR_R_CHAR_P 1" >>confdefs.h fi @@ -29298,7 +29510,7 @@ fi XGETTEXT_EXTRA_OPTIONS= - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ctype.h defines __header_inline" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ctype.h defines __header_inline" >&5 printf %s "checking whether ctype.h defines __header_inline... " >&6; } if test ${gl_cv_have___header_inline+y} then : @@ -29322,11 +29534,11 @@ fi rm -f conftest.err conftest.i conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have___header_inline" >&5 -printf "%s\n" "$gl_cv_have___header_inline" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have___header_inline" >&5 +printf '%s\n' "$gl_cv_have___header_inline" >&6; } if test "$gl_cv_have___header_inline" = yes; then -printf "%s\n" "@%:@define HAVE___HEADER_INLINE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE___HEADER_INLINE 1" >>confdefs.h fi @@ -29377,7 +29589,7 @@ printf "%s\n" "@%:@define HAVE___HEADER_INLINE 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working fcntl.h" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working fcntl.h" >&5 printf %s "checking for working fcntl.h... " >&6; } if test ${gl_cv_header_working_fcntl_h+y} then : @@ -29511,15 +29723,15 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_fcntl_h" >&5 -printf "%s\n" "$gl_cv_header_working_fcntl_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_fcntl_h" >&5 +printf '%s\n' "$gl_cv_header_working_fcntl_h" >&6; } case $gl_cv_header_working_fcntl_h in #( *O_NOATIME* | no | cross-compiling) ac_val=0;; #( *) ac_val=1;; esac -printf "%s\n" "@%:@define HAVE_WORKING_O_NOATIME $ac_val" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WORKING_O_NOATIME $ac_val" >>confdefs.h case $gl_cv_header_working_fcntl_h in #( @@ -29527,7 +29739,7 @@ printf "%s\n" "@%:@define HAVE_WORKING_O_NOATIME $ac_val" >>confdefs.h *) ac_val=1;; esac -printf "%s\n" "@%:@define HAVE_WORKING_O_NOFOLLOW $ac_val" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WORKING_O_NOFOLLOW $ac_val" >>confdefs.h @@ -29562,7 +29774,7 @@ esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext -printf "%s\n" "@%:@define pid_t $ac_pid_type" >>confdefs.h +printf '%s\n' "@%:@define pid_t $ac_pid_type" >>confdefs.h ;; esac @@ -29575,7 +29787,7 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define mode_t int" >>confdefs.h +printf '%s\n' "@%:@define mode_t int" >>confdefs.h ;; esac fi @@ -29594,7 +29806,7 @@ fi if test $gl_cv_have_include_next = yes; then gl_cv_next_fcntl_h='<'fcntl.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_fcntl_h+y} then : @@ -29639,8 +29851,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_fcntl_h" >&5 -printf "%s\n" "$gl_cv_next_fcntl_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_fcntl_h" >&5 +printf '%s\n' "$gl_cv_next_fcntl_h" >&6; } fi NEXT_FCNTL_H=$gl_cv_next_fcntl_h @@ -29692,7 +29904,7 @@ printf "%s\n" "$gl_cv_next_fcntl_h" >&6; } REPLACE_STAT=0; REPLACE_UTIMENSAT=0; -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 printf %s "checking whether stat file-mode macros are broken... " >&6; } if test ${ac_cv_header_stat_broken+y} then : @@ -29730,11 +29942,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 -printf "%s\n" "$ac_cv_header_stat_broken" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 +printf '%s\n' "$ac_cv_header_stat_broken" >&6; } if test $ac_cv_header_stat_broken = yes; then -printf "%s\n" "@%:@define STAT_MACROS_BROKEN 1" >>confdefs.h +printf '%s\n' "@%:@define STAT_MACROS_BROKEN 1" >>confdefs.h fi @@ -29742,7 +29954,7 @@ fi case "$host_os" in mingw* | windows*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 64-bit off_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for 64-bit off_t" >&5 printf %s "checking for 64-bit off_t... " >&6; } if test ${gl_cv_type_off_t_64+y} then : @@ -29772,14 +29984,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_off_t_64" >&5 -printf "%s\n" "$gl_cv_type_off_t_64" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_off_t_64" >&5 +printf '%s\n' "$gl_cv_type_off_t_64" >&6; } if test $gl_cv_type_off_t_64 = no; then WINDOWS_64_BIT_OFF_T=1 else WINDOWS_64_BIT_OFF_T=0 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for 64-bit st_size" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for 64-bit st_size" >&5 printf %s "checking for 64-bit st_size... " >&6; } if test ${gl_cv_member_st_size_64+y} then : @@ -29810,8 +30022,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_member_st_size_64" >&5 -printf "%s\n" "$gl_cv_member_st_size_64" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_member_st_size_64" >&5 +printf '%s\n' "$gl_cv_member_st_size_64" >&6; } if test $gl_cv_member_st_size_64 = no; then WINDOWS_64_BIT_ST_SIZE=1 else @@ -29841,7 +30053,7 @@ printf "%s\n" "$gl_cv_member_st_size_64" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_sys_stat_h='<'sys/stat.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_sys_stat_h+y} then : @@ -29892,8 +30104,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_stat_h" >&5 -printf "%s\n" "$gl_cv_next_sys_stat_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_stat_h" >&5 +printf '%s\n' "$gl_cv_next_sys_stat_h" >&6; } fi NEXT_SYS_STAT_H=$gl_cv_next_sys_stat_h @@ -29930,7 +30142,7 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define nlink_t int" >>confdefs.h +printf '%s\n' "@%:@define nlink_t int" >>confdefs.h ;; esac fi @@ -29949,7 +30161,7 @@ fi ac_fn_c_check_header_compile "$LINENO" "sdkddkver.h" "ac_cv_header_sdkddkver_h" "$ac_includes_default" if test "x$ac_cv_header_sdkddkver_h" = xyes then : - printf "%s\n" "@%:@define HAVE_SDKDDKVER_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SDKDDKVER_H 1" >>confdefs.h fi @@ -30043,7 +30255,7 @@ fi -ac_fn_check_decl "$LINENO" "getdtablesize" "ac_cv_have_decl_getdtablesize" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "getdtablesize" "ac_cv_have_decl_getdtablesize" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_getdtablesize" = xyes then : ac_have_decl=1 @@ -30051,7 +30263,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_GETDTABLESIZE $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_GETDTABLESIZE $ac_have_decl" >>confdefs.h @@ -30070,7 +30282,7 @@ printf "%s\n" "@%:@define HAVE_DECL_GETDTABLESIZE $ac_have_decl" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_getopt_h='<'getopt.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_getopt_h+y} then : @@ -30121,8 +30333,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_getopt_h" >&5 -printf "%s\n" "$gl_cv_next_getopt_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_getopt_h" >&5 +printf '%s\n' "$gl_cv_next_getopt_h" >&6; } fi NEXT_GETOPT_H=$gl_cv_next_getopt_h @@ -30153,7 +30365,7 @@ do : ac_fn_c_check_header_compile "$LINENO" "getopt.h" "ac_cv_header_getopt_h" "$ac_includes_default" if test "x$ac_cv_header_getopt_h" = xyes then : - printf "%s\n" "@%:@define HAVE_GETOPT_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_GETOPT_H 1" >>confdefs.h else case e in @%:@( e) gl_replace_getopt=yes ;; @@ -30170,7 +30382,7 @@ do : ac_fn_c_check_func "$LINENO" "getopt_long_only" "ac_cv_func_getopt_long_only" if test "x$ac_cv_func_getopt_long_only" = xyes then : - printf "%s\n" "@%:@define HAVE_GETOPT_LONG_ONLY 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_GETOPT_LONG_ONLY 1" >>confdefs.h else case e in @%:@( e) gl_replace_getopt=yes ;; @@ -30181,7 +30393,7 @@ done fi if test -z "$gl_replace_getopt"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether getopt is POSIX compatible" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether getopt is POSIX compatible" >&5 printf %s "checking whether getopt is POSIX compatible... " >&6; } if test ${gl_cv_func_getopt_posix+y} then : @@ -30191,8 +30403,8 @@ else case e in @%:@( if test $cross_compiling = no; then if test "$cross_compiling" = yes then : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See 'config.log' for more details" "$LINENO" 5; } else case e in @%:@( @@ -30240,8 +30452,8 @@ fi if test $gl_cv_func_getopt_posix = maybe; then if test "$cross_compiling" = yes then : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See 'config.log' for more details" "$LINENO" 5; } else case e in @%:@( @@ -30304,8 +30516,8 @@ fi if test $gl_cv_func_getopt_posix = maybe; then if test "$cross_compiling" = yes then : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See 'config.log' for more details" "$LINENO" 5; } else case e in @%:@( @@ -30356,15 +30568,15 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_posix" >&5 -printf "%s\n" "$gl_cv_func_getopt_posix" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_posix" >&5 +printf '%s\n' "$gl_cv_func_getopt_posix" >&6; } case "$gl_cv_func_getopt_posix" in *no) gl_replace_getopt=yes ;; esac fi if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working GNU getopt function" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working GNU getopt function" >&5 printf %s "checking for working GNU getopt function... " >&6; } if test ${gl_cv_func_getopt_gnu+y} then : @@ -30608,12 +30820,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_gnu" >&5 -printf "%s\n" "$gl_cv_func_getopt_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_gnu" >&5 +printf '%s\n' "$gl_cv_func_getopt_gnu" >&6; } if test "$gl_cv_func_getopt_gnu" != yes; then gl_replace_getopt=yes else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working GNU getopt_long function" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working GNU getopt_long function" >&5 printf %s "checking for working GNU getopt_long function... " >&6; } if test ${gl_cv_func_getopt_long_gnu+y} then : @@ -30675,8 +30887,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_long_gnu" >&5 -printf "%s\n" "$gl_cv_func_getopt_long_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getopt_long_gnu" >&5 +printf '%s\n' "$gl_cv_func_getopt_long_gnu" >&6; } case "$gl_cv_func_getopt_long_gnu" in *yes) ;; *) gl_replace_getopt=yes ;; @@ -30779,7 +30991,7 @@ rm -rf conftest* if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then # The program links fine without libpthread. But it may actually # need to link with libpthread in order to create multiple threads. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -30820,8 +31032,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -30837,13 +31049,13 @@ then : case "$host_os" in solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) -printf "%s\n" "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h +printf '%s\n' "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h esac fi else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 printf %s "checking for pthread_kill in -lthr... " >&6; } if test ${ac_cv_lib_thr_pthread_kill+y} then : @@ -30884,8 +31096,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_thr_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_thr_pthread_kill" >&6; } if test "x$ac_cv_lib_thr_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -30902,7 +31114,7 @@ fi elif test $gl_pthread_api != yes; then # Some library is needed. Try libpthread and libc_r. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -30943,8 +31155,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : gl_pthread_api=yes @@ -30954,7 +31166,7 @@ fi if test $gl_pthread_api != yes; then # For FreeBSD 4. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 printf %s "checking for pthread_kill in -lc_r... " >&6; } if test ${ac_cv_lib_c_r_pthread_kill+y} then : @@ -30995,8 +31207,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_c_r_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_c_r_pthread_kill" >&6; } if test "x$ac_cv_lib_c_r_pthread_kill" = xyes then : gl_pthread_api=yes @@ -31008,15 +31220,15 @@ fi fi echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&5 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 printf %s "checking whether POSIX threads API is available... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 -printf "%s\n" "$gl_pthread_api" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 +printf '%s\n' "$gl_pthread_api" >&6; } if test $gl_pthread_api = yes; then -printf "%s\n" "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h fi @@ -31036,7 +31248,7 @@ then : SCHED_YIELD_LIB= else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 printf %s "checking for sched_yield in -lrt... " >&6; } if test ${ac_cv_lib_rt_sched_yield+y} then : @@ -31077,13 +31289,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_rt_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_rt_sched_yield" >&6; } if test "x$ac_cv_lib_rt_sched_yield" = xyes then : SCHED_YIELD_LIB=-lrt else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 printf %s "checking for sched_yield in -lposix4... " >&6; } if test ${ac_cv_lib_posix4_sched_yield+y} then : @@ -31124,8 +31336,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_posix4_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_posix4_sched_yield" >&6; } if test "x$ac_cv_lib_posix4_sched_yield" = xyes then : SCHED_YIELD_LIB=-lposix4 @@ -31153,7 +31365,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether setlocale (LC_ALL, NULL) is multithread-safe" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether setlocale (LC_ALL, NULL) is multithread-safe" >&5 printf %s "checking whether setlocale (LC_ALL, NULL) is multithread-safe... " >&6; } if test ${gl_cv_func_setlocale_null_all_mtsafe+y} then : @@ -31197,8 +31409,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_all_mtsafe" >&5 -printf "%s\n" "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_all_mtsafe" >&5 +printf '%s\n' "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } case "$host_os" in mingw* | windows*) ;; *) @@ -31212,10 +31424,10 @@ printf "%s\n" "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } *) SETLOCALE_NULL_ALL_MTSAFE=0 ;; esac -printf "%s\n" "@%:@define SETLOCALE_NULL_ALL_MTSAFE $SETLOCALE_NULL_ALL_MTSAFE" >>confdefs.h +printf '%s\n' "@%:@define SETLOCALE_NULL_ALL_MTSAFE $SETLOCALE_NULL_ALL_MTSAFE" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether setlocale (category, NULL) is multithread-safe" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether setlocale (category, NULL) is multithread-safe" >&5 printf %s "checking whether setlocale (category, NULL) is multithread-safe... " >&6; } if test ${gl_cv_func_setlocale_null_one_mtsafe+y} then : @@ -31235,8 +31447,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_one_mtsafe" >&5 -printf "%s\n" "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_one_mtsafe" >&5 +printf '%s\n' "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } case "$host_os" in mingw* | windows*) ;; *) @@ -31250,7 +31462,7 @@ printf "%s\n" "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } *) SETLOCALE_NULL_ONE_MTSAFE=0 ;; esac -printf "%s\n" "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" >>confdefs.h +printf '%s\n' "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" >>confdefs.h if test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0; then @@ -31261,7 +31473,7 @@ printf "%s\n" "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 printf %s "checking whether imported symbols can be declared weak... " >&6; } if test ${gl_cv_have_weak+y} then : @@ -31365,12 +31577,12 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 -printf "%s\n" "$gl_cv_have_weak" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 +printf '%s\n' "$gl_cv_have_weak" >&6; } case "$gl_cv_have_weak" in *yes) -printf "%s\n" "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h ;; esac @@ -31926,7 +32138,7 @@ fi done - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for iconv" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for iconv" >&5 printf %s "checking for iconv... " >&6; } if test ${am_cv_func_iconv+y} then : @@ -31988,10 +32200,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv" >&5 -printf "%s\n" "$am_cv_func_iconv" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv" >&5 +printf '%s\n' "$am_cv_func_iconv" >&6; } if test "$am_cv_func_iconv" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working iconv" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working iconv" >&5 printf %s "checking for working iconv... " >&6; } if test ${am_cv_func_iconv_works+y} then : @@ -32150,8 +32362,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv_works" >&5 -printf "%s\n" "$am_cv_func_iconv_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv_works" >&5 +printf '%s\n' "$am_cv_func_iconv_works" >&6; } case "$am_cv_func_iconv_works" in *no) am_func_iconv=no am_cv_lib_iconv=no ;; *) am_func_iconv=yes ;; @@ -32161,14 +32373,14 @@ printf "%s\n" "$am_cv_func_iconv_works" >&6; } fi if test "$am_func_iconv" = yes; then -printf "%s\n" "@%:@define HAVE_ICONV 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ICONV 1" >>confdefs.h fi if test "$am_cv_lib_iconv" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libiconv" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to link with libiconv" >&5 printf %s "checking how to link with libiconv... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBICONV" >&5 -printf "%s\n" "$LIBICONV" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIBICONV" >&5 +printf '%s\n' "$LIBICONV" >&6; } else CPPFLAGS="$gl_saved_CPPFLAGS" LIBICONV= @@ -32178,7 +32390,7 @@ printf "%s\n" "$LIBICONV" >&6; } if test "$am_cv_func_iconv" = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether iconv is compatible with its POSIX signature" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether iconv is compatible with its POSIX signature" >&5 printf %s "checking whether iconv is compatible with its POSIX signature... " >&6; } if test ${gl_cv_iconv_nonconst+y} then : @@ -32214,8 +32426,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_iconv_nonconst" >&5 -printf "%s\n" "$gl_cv_iconv_nonconst" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_iconv_nonconst" >&5 +printf '%s\n' "$gl_cv_iconv_nonconst" >&6; } else gl_cv_iconv_nonconst=yes fi @@ -32225,7 +32437,7 @@ printf "%s\n" "$gl_cv_iconv_nonconst" >&6; } iconv_arg1="const" fi -printf "%s\n" "@%:@define ICONV_CONST $iconv_arg1" >>confdefs.h +printf '%s\n' "@%:@define ICONV_CONST $iconv_arg1" >>confdefs.h if test $gl_cv_iconv_nonconst != yes; then @@ -32269,7 +32481,7 @@ printf "%s\n" "@%:@define ICONV_CONST $iconv_arg1" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_iconv_h='<'iconv.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_iconv_h+y} then : @@ -32320,8 +32532,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_iconv_h" >&5 -printf "%s\n" "$gl_cv_next_iconv_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_iconv_h" >&5 +printf '%s\n' "$gl_cv_next_iconv_h" >&6; } fi NEXT_ICONV_H=$gl_cv_next_iconv_h @@ -32344,7 +32556,7 @@ printf "%s\n" "$gl_cv_next_iconv_h" >&6; } -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 printf %s "checking for inline... " >&6; } if test ${ac_cv_c_inline+y} then : @@ -32371,8 +32583,8 @@ done ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 -printf "%s\n" "$ac_cv_c_inline" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 +printf '%s\n' "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; @@ -32403,7 +32615,7 @@ esac if test $gl_cv_have_include_next = yes; then gl_cv_next_limits_h='<'limits.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_limits_h+y} then : @@ -32454,8 +32666,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_limits_h" >&5 -printf "%s\n" "$gl_cv_next_limits_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_limits_h" >&5 +printf '%s\n' "$gl_cv_next_limits_h" >&6; } fi NEXT_LIMITS_H=$gl_cv_next_limits_h @@ -32472,7 +32684,7 @@ printf "%s\n" "$gl_cv_next_limits_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether limits.h has WORD_BIT, BOOL_WIDTH etc." >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether limits.h has WORD_BIT, BOOL_WIDTH etc." >&5 printf %s "checking whether limits.h has WORD_BIT, BOOL_WIDTH etc.... " >&6; } if test ${gl_cv_header_limits_width+y} then : @@ -32509,12 +32721,12 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_limits_width" >&5 -printf "%s\n" "$gl_cv_header_limits_width" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_limits_width" >&5 +printf '%s\n' "$gl_cv_header_limits_width" >&6; } GL_GENERATE_LIMITS_H=true if test "$gl_cv_header_limits_width" = yes then : - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether limits.h has SSIZE_MAX" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether limits.h has SSIZE_MAX" >&5 printf %s "checking whether limits.h has SSIZE_MAX... " >&6; } if test ${gl_cv_header_limits_ssize_max+y} then : @@ -32538,15 +32750,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_limits_ssize_max" >&5 -printf "%s\n" "$gl_cv_header_limits_ssize_max" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_limits_ssize_max" >&5 +printf '%s\n' "$gl_cv_header_limits_ssize_max" >&6; } if test "$gl_cv_header_limits_ssize_max" = yes; then GL_GENERATE_LIMITS_H=false fi fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for wint_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for wint_t" >&5 printf %s "checking for wint_t... " >&6; } if test ${gt_cv_c_wint_t+y} then : @@ -32574,14 +32786,14 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_c_wint_t" >&5 -printf "%s\n" "$gt_cv_c_wint_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_c_wint_t" >&5 +printf '%s\n' "$gt_cv_c_wint_t" >&6; } if test $gt_cv_c_wint_t = yes; then -printf "%s\n" "@%:@define HAVE_WINT_T 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WINT_T 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether wint_t is large enough" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether wint_t is large enough" >&5 printf %s "checking whether wint_t is large enough... " >&6; } if test ${gl_cv_type_wint_t_large_enough+y} then : @@ -32610,8 +32822,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wint_t_large_enough" >&5 -printf "%s\n" "$gl_cv_type_wint_t_large_enough" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wint_t_large_enough" >&5 +printf '%s\n' "$gl_cv_type_wint_t_large_enough" >&6; } if test $gl_cv_type_wint_t_large_enough = no; then GNULIBHEADERS_OVERRIDE_WINT_T=1 else @@ -32623,7 +32835,7 @@ printf "%s\n" "$gl_cv_type_wint_t_large_enough" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler produces multi-arch binaries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler produces multi-arch binaries" >&5 printf %s "checking whether the compiler produces multi-arch binaries... " >&6; } if test ${gl_cv_c_multiarch+y} then : @@ -32667,8 +32879,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_multiarch" >&5 -printf "%s\n" "$gl_cv_c_multiarch" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_multiarch" >&5 +printf '%s\n' "$gl_cv_c_multiarch" >&6; } if test $gl_cv_c_multiarch = yes; then APPLE_UNIVERSAL_BUILD=1 else @@ -32682,10 +32894,10 @@ printf "%s\n" "$gl_cv_c_multiarch" >&6; } -printf "%s\n" "@%:@define HAVE_LONG_LONG_INT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_LONG_LONG_INT 1" >>confdefs.h -printf "%s\n" "@%:@define HAVE_UNSIGNED_LONG_LONG_INT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_UNSIGNED_LONG_LONG_INT 1" >>confdefs.h @@ -32724,7 +32936,7 @@ printf "%s\n" "@%:@define HAVE_UNSIGNED_LONG_LONG_INT 1" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_stdint_h='<'stdint.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_stdint_h+y} then : @@ -32775,8 +32987,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdint_h" >&5 -printf "%s\n" "$gl_cv_next_stdint_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdint_h" >&5 +printf '%s\n' "$gl_cv_next_stdint_h" >&6; } fi NEXT_STDINT_H=$gl_cv_next_stdint_h @@ -32800,7 +33012,7 @@ printf "%s\n" "$gl_cv_next_stdint_h" >&6; } if test $ac_cv_header_stdint_h = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stdint.h conforms to C99" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stdint.h conforms to C99" >&5 printf %s "checking whether stdint.h conforms to C99... " >&6; } if test ${gl_cv_header_working_stdint_h+y} then : @@ -33080,8 +33292,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_stdint_h" >&5 -printf "%s\n" "$gl_cv_header_working_stdint_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_stdint_h" >&5 +printf '%s\n' "$gl_cv_header_working_stdint_h" >&6; } fi HAVE_C99_STDINT_H=0 @@ -33091,7 +33303,7 @@ printf "%s\n" "$gl_cv_header_working_stdint_h" >&6; } case "$gl_cv_header_working_stdint_h" in *yes) HAVE_C99_STDINT_H=1 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stdint.h works without ISO C predefines" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stdint.h works without ISO C predefines" >&5 printf %s "checking whether stdint.h works without ISO C predefines... " >&6; } if test ${gl_cv_header_stdint_without_STDC_macros+y} then : @@ -33132,18 +33344,18 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_stdint_without_STDC_macros" >&5 -printf "%s\n" "$gl_cv_header_stdint_without_STDC_macros" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_stdint_without_STDC_macros" >&5 +printf '%s\n' "$gl_cv_header_stdint_without_STDC_macros" >&6; } if test $gl_cv_header_stdint_without_STDC_macros = no; then -printf "%s\n" "@%:@define __STDC_CONSTANT_MACROS 1" >>confdefs.h +printf '%s\n' "@%:@define __STDC_CONSTANT_MACROS 1" >>confdefs.h -printf "%s\n" "@%:@define __STDC_LIMIT_MACROS 1" >>confdefs.h +printf '%s\n' "@%:@define __STDC_LIMIT_MACROS 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stdint.h has UINTMAX_WIDTH etc." >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stdint.h has UINTMAX_WIDTH etc." >&5 printf %s "checking whether stdint.h has UINTMAX_WIDTH etc.... " >&6; } if test ${gl_cv_header_stdint_width+y} then : @@ -33183,8 +33395,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_stdint_width" >&5 -printf "%s\n" "$gl_cv_header_stdint_width" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_stdint_width" >&5 +printf '%s\n' "$gl_cv_header_stdint_width" >&6; } if test "$gl_cv_header_stdint_width" = yes; then GL_GENERATE_STDINT_H=false fi @@ -33193,13 +33405,13 @@ printf "%s\n" "$gl_cv_header_stdint_width" >&6; } ac_fn_c_check_header_compile "$LINENO" "sys/inttypes.h" "ac_cv_header_sys_inttypes_h" "$ac_includes_default" if test "x$ac_cv_header_sys_inttypes_h" = xyes then : - printf "%s\n" "@%:@define HAVE_SYS_INTTYPES_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SYS_INTTYPES_H 1" >>confdefs.h fi ac_fn_c_check_header_compile "$LINENO" "sys/bitypes.h" "ac_cv_header_sys_bitypes_h" "$ac_includes_default" if test "x$ac_cv_header_sys_bitypes_h" = xyes then : - printf "%s\n" "@%:@define HAVE_SYS_BITYPES_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SYS_BITYPES_H 1" >>confdefs.h fi @@ -33215,7 +33427,7 @@ fi for gltype in ptrdiff_t size_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 printf %s "checking for bit size of $gltype... " >&6; } if eval test \${gl_cv_bitsizeof_${gltype}+y} then : @@ -33241,14 +33453,16 @@ fi esac fi eval ac_res=\$gl_cv_bitsizeof_${gltype} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval result=\$gl_cv_bitsizeof_${gltype} if test $result = unknown; then result=0 fi GLTYPE=`echo "$gltype" | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - printf "%s\n" "@%:@define BITSIZEOF_${GLTYPE} $result" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define BITSIZEOF_${GLTYPE} $result +_ACEOF eval BITSIZEOF_${GLTYPE}=\$result done @@ -33258,7 +33472,7 @@ printf "%s\n" "$ac_res" >&6; } for gltype in sig_atomic_t wchar_t wint_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for bit size of $gltype" >&5 printf %s "checking for bit size of $gltype... " >&6; } if eval test \${gl_cv_bitsizeof_${gltype}+y} then : @@ -33284,14 +33498,16 @@ fi esac fi eval ac_res=\$gl_cv_bitsizeof_${gltype} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval result=\$gl_cv_bitsizeof_${gltype} if test $result = unknown; then result=0 fi GLTYPE=`echo "$gltype" | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - printf "%s\n" "@%:@define BITSIZEOF_${GLTYPE} $result" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define BITSIZEOF_${GLTYPE} $result +_ACEOF eval BITSIZEOF_${GLTYPE}=\$result done @@ -33300,7 +33516,7 @@ printf "%s\n" "$ac_res" >&6; } for gltype in sig_atomic_t wchar_t wint_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $gltype is signed" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $gltype is signed" >&5 printf %s "checking whether $gltype is signed... " >&6; } if eval test \${gl_cv_type_${gltype}_signed+y} then : @@ -33337,12 +33553,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext esac fi eval ac_res=\$gl_cv_type_${gltype}_signed - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } eval result=\$gl_cv_type_${gltype}_signed GLTYPE=`echo $gltype | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` if test "$result" = yes; then - printf "%s\n" "@%:@define HAVE_SIGNED_${GLTYPE} 1" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define HAVE_SIGNED_${GLTYPE} 1 +_ACEOF eval HAVE_SIGNED_${GLTYPE}=1 else @@ -33357,7 +33575,7 @@ printf "%s\n" "$ac_res" >&6; } for gltype in ptrdiff_t size_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $gltype integer literal suffix" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $gltype integer literal suffix" >&5 printf %s "checking for $gltype integer literal suffix... " >&6; } if eval test \${gl_cv_type_${gltype}_suffix+y} then : @@ -33411,13 +33629,15 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext esac fi eval ac_res=\$gl_cv_type_${gltype}_suffix - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } GLTYPE=`echo $gltype | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` eval result=\$gl_cv_type_${gltype}_suffix test "$result" = no && result= eval ${GLTYPE}_SUFFIX=\$result - printf "%s\n" "@%:@define ${GLTYPE}_SUFFIX $result" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define ${GLTYPE}_SUFFIX $result +_ACEOF done @@ -33426,7 +33646,7 @@ printf "%s\n" "$ac_res" >&6; } for gltype in sig_atomic_t wchar_t wint_t ; do - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $gltype integer literal suffix" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $gltype integer literal suffix" >&5 printf %s "checking for $gltype integer literal suffix... " >&6; } if eval test \${gl_cv_type_${gltype}_suffix+y} then : @@ -33480,13 +33700,15 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext esac fi eval ac_res=\$gl_cv_type_${gltype}_suffix - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -printf "%s\n" "$ac_res" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf '%s\n' "$ac_res" >&6; } GLTYPE=`echo $gltype | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` eval result=\$gl_cv_type_${gltype}_suffix test "$result" = no && result= eval ${GLTYPE}_SUFFIX=\$result - printf "%s\n" "@%:@define ${GLTYPE}_SUFFIX $result" >>confdefs.h + cat >>confdefs.h <<_ACEOF +@%:@define ${GLTYPE}_SUFFIX $result +_ACEOF done @@ -33543,7 +33765,7 @@ printf "%s\n" "$ac_res" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_inttypes_h='<'inttypes.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_inttypes_h+y} then : @@ -33594,8 +33816,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_inttypes_h" >&5 -printf "%s\n" "$gl_cv_next_inttypes_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_inttypes_h" >&5 +printf '%s\n' "$gl_cv_next_inttypes_h" >&6; } fi NEXT_INTTYPES_H=$gl_cv_next_inttypes_h @@ -33695,7 +33917,7 @@ printf "%s\n" "$gl_cv_next_inttypes_h" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_wctype_h='<'wctype.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_wctype_h+y} then : @@ -33746,8 +33968,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_wctype_h" >&5 -printf "%s\n" "$gl_cv_next_wctype_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_wctype_h" >&5 +printf '%s\n' "$gl_cv_next_wctype_h" >&6; } fi NEXT_WCTYPE_H=$gl_cv_next_wctype_h @@ -33765,7 +33987,7 @@ printf "%s\n" "$gl_cv_next_wctype_h" >&6; } if test $ac_cv_header_wctype_h = yes; then if test $ac_cv_func_iswcntrl = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether iswcntrl works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether iswcntrl works" >&5 printf %s "checking whether iswcntrl works... " >&6; } if test ${gl_cv_func_iswcntrl_works+y} then : @@ -33821,8 +34043,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswcntrl_works" >&5 -printf "%s\n" "$gl_cv_func_iswcntrl_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswcntrl_works" >&5 +printf '%s\n' "$gl_cv_func_iswcntrl_works" >&6; } fi HAVE_WCTYPE_H=1 else @@ -33850,7 +34072,7 @@ printf "%s\n" "$gl_cv_func_iswcntrl_works" >&6; } ac_fn_c_check_func "$LINENO" "towlower" "ac_cv_func_towlower" if test "x$ac_cv_func_towlower" = xyes then : - printf "%s\n" "@%:@define HAVE_TOWLOWER 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_TOWLOWER 1" >>confdefs.h fi @@ -33862,7 +34084,7 @@ fi # include #endif -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_towlower" = xyes then : ac_have_decl=1 @@ -33870,7 +34092,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_TOWLOWER $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_TOWLOWER $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_towlower = yes; then REPLACE_TOWLOWER=1 @@ -33885,7 +34107,7 @@ printf "%s\n" "@%:@define HAVE_DECL_TOWLOWER $ac_have_decl" >>confdefs.h : fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for wctype_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for wctype_t" >&5 printf %s "checking for wctype_t... " >&6; } if test ${gl_cv_type_wctype_t+y} then : @@ -33918,13 +34140,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wctype_t" >&5 -printf "%s\n" "$gl_cv_type_wctype_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wctype_t" >&5 +printf '%s\n' "$gl_cv_type_wctype_t" >&6; } if test $gl_cv_type_wctype_t = no; then HAVE_WCTYPE_T=0 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for wctrans_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for wctrans_t" >&5 printf %s "checking for wctrans_t... " >&6; } if test ${gl_cv_type_wctrans_t+y} then : @@ -33955,8 +34177,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wctrans_t" >&5 -printf "%s\n" "$gl_cv_type_wctrans_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_wctrans_t" >&5 +printf '%s\n' "$gl_cv_type_wctrans_t" >&6; } if test $gl_cv_type_wctrans_t = no; then HAVE_WCTRANS_T=0 fi @@ -34021,7 +34243,7 @@ printf "%s\n" "$gl_cv_type_wctrans_t" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_langinfo_h='<'langinfo.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_langinfo_h+y} then : @@ -34072,8 +34294,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_langinfo_h" >&5 -printf "%s\n" "$gl_cv_next_langinfo_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_langinfo_h" >&5 +printf '%s\n' "$gl_cv_next_langinfo_h" >&6; } fi NEXT_LANGINFO_H=$gl_cv_next_langinfo_h @@ -34098,7 +34320,7 @@ printf "%s\n" "$gl_cv_next_langinfo_h" >&6; } if test $ac_cv_header_langinfo_h = yes; then HAVE_LANGINFO_H=1 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines CODESET" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines CODESET" >&5 printf %s "checking whether langinfo.h defines CODESET... " >&6; } if test ${gl_cv_header_langinfo_codeset+y} then : @@ -34128,12 +34350,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_codeset" >&5 -printf "%s\n" "$gl_cv_header_langinfo_codeset" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_codeset" >&5 +printf '%s\n' "$gl_cv_header_langinfo_codeset" >&6; } if test $gl_cv_header_langinfo_codeset = yes; then HAVE_LANGINFO_CODESET=1 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines T_FMT_AMPM" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines T_FMT_AMPM" >&5 printf %s "checking whether langinfo.h defines T_FMT_AMPM... " >&6; } if test ${gl_cv_header_langinfo_t_fmt_ampm+y} then : @@ -34163,12 +34385,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_t_fmt_ampm" >&5 -printf "%s\n" "$gl_cv_header_langinfo_t_fmt_ampm" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_t_fmt_ampm" >&5 +printf '%s\n' "$gl_cv_header_langinfo_t_fmt_ampm" >&6; } if test $gl_cv_header_langinfo_t_fmt_ampm = yes; then HAVE_LANGINFO_T_FMT_AMPM=1 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines ALTMON_1" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines ALTMON_1" >&5 printf %s "checking whether langinfo.h defines ALTMON_1... " >&6; } if test ${gl_cv_header_langinfo_altmon+y} then : @@ -34198,12 +34420,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_altmon" >&5 -printf "%s\n" "$gl_cv_header_langinfo_altmon" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_altmon" >&5 +printf '%s\n' "$gl_cv_header_langinfo_altmon" >&6; } if test $gl_cv_header_langinfo_altmon = yes; then HAVE_LANGINFO_ALTMON=1 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines ERA" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines ERA" >&5 printf %s "checking whether langinfo.h defines ERA... " >&6; } if test ${gl_cv_header_langinfo_era+y} then : @@ -34233,12 +34455,12 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_era" >&5 -printf "%s\n" "$gl_cv_header_langinfo_era" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_era" >&5 +printf '%s\n' "$gl_cv_header_langinfo_era" >&6; } if test $gl_cv_header_langinfo_era = yes; then HAVE_LANGINFO_ERA=1 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines YESEXPR" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether langinfo.h defines YESEXPR" >&5 printf %s "checking whether langinfo.h defines YESEXPR... " >&6; } if test ${gl_cv_header_langinfo_yesexpr+y} then : @@ -34268,8 +34490,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_yesexpr" >&5 -printf "%s\n" "$gl_cv_header_langinfo_yesexpr" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_langinfo_yesexpr" >&5 +printf '%s\n' "$gl_cv_header_langinfo_yesexpr" >&6; } if test $gl_cv_header_langinfo_yesexpr = yes; then HAVE_LANGINFO_YESEXPR=1 fi @@ -34311,7 +34533,7 @@ printf "%s\n" "$gl_cv_header_langinfo_yesexpr" >&6; } HAVE_WCHAR_T=1; - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for wchar_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for wchar_t" >&5 printf %s "checking for wchar_t... " >&6; } if test ${gt_cv_c_wchar_t+y} then : @@ -34339,11 +34561,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_c_wchar_t" >&5 -printf "%s\n" "$gt_cv_c_wchar_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_c_wchar_t" >&5 +printf '%s\n' "$gt_cv_c_wchar_t" >&6; } if test $gt_cv_c_wchar_t = yes; then -printf "%s\n" "@%:@define HAVE_WCHAR_T 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WCHAR_T 1" >>confdefs.h fi @@ -34355,7 +34577,7 @@ printf "%s\n" "@%:@define HAVE_WCHAR_T 1" >>confdefs.h GL_GENERATE_STDDEF_H=false - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for good max_align_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for good max_align_t" >&5 printf %s "checking for good max_align_t... " >&6; } if test ${gl_cv_type_max_align_t+y} then : @@ -34403,8 +34625,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_max_align_t" >&5 -printf "%s\n" "$gl_cv_type_max_align_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_type_max_align_t" >&5 +printf '%s\n' "$gl_cv_type_max_align_t" >&6; } if test $gl_cv_type_max_align_t = no; then HAVE_MAX_ALIGN_T=0 GL_GENERATE_STDDEF_H=true @@ -34415,7 +34637,7 @@ printf "%s\n" "$gl_cv_type_max_align_t" >&6; } GL_GENERATE_STDDEF_H=true fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether NULL can be used in arbitrary expressions" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether NULL can be used in arbitrary expressions" >&5 printf %s "checking whether NULL can be used in arbitrary expressions... " >&6; } if test ${gl_cv_decl_null_works+y} then : @@ -34444,14 +34666,14 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_decl_null_works" >&5 -printf "%s\n" "$gl_cv_decl_null_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_decl_null_works" >&5 +printf '%s\n' "$gl_cv_decl_null_works" >&6; } if test $gl_cv_decl_null_works = no; then REPLACE_NULL=1 GL_GENERATE_STDDEF_H=true fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for unreachable" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for unreachable" >&5 printf %s "checking for unreachable... " >&6; } if test ${gl_cv_func_unreachable+y} then : @@ -34482,8 +34704,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_unreachable" >&5 -printf "%s\n" "$gl_cv_func_unreachable" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_unreachable" >&5 +printf '%s\n' "$gl_cv_func_unreachable" >&6; } if test $gl_cv_func_unreachable = no; then GL_GENERATE_STDDEF_H=true fi @@ -34500,7 +34722,7 @@ printf "%s\n" "$gl_cv_func_unreachable" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_stddef_h='<'stddef.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_stddef_h+y} then : @@ -34545,8 +34767,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stddef_h" >&5 -printf "%s\n" "$gl_cv_next_stddef_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stddef_h" >&5 +printf '%s\n' "$gl_cv_next_stddef_h" >&6; } fi NEXT_STDDEF_H=$gl_cv_next_stddef_h @@ -34568,7 +34790,7 @@ printf "%s\n" "$gl_cv_next_stddef_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether locale.h defines locale_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether locale.h defines locale_t" >&5 printf %s "checking whether locale.h defines locale_t... " >&6; } if test ${gl_cv_header_locale_has_locale_t+y} then : @@ -34597,8 +34819,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_locale_has_locale_t" >&5 -printf "%s\n" "$gl_cv_header_locale_has_locale_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_locale_has_locale_t" >&5 +printf '%s\n' "$gl_cv_header_locale_has_locale_t" >&6; } if test $ac_cv_header_xlocale_h = yes; then @@ -34633,12 +34855,12 @@ printf "%s\n" "$gl_cv_header_locale_has_locale_t" >&6; } case "$host_os" in solaris*) -printf "%s\n" "@%:@define _LCONV_C99 1" >>confdefs.h +printf '%s\n' "@%:@define _LCONV_C99 1" >>confdefs.h ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether locale.h conforms to POSIX:2001" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether locale.h conforms to POSIX:2001" >&5 printf %s "checking whether locale.h conforms to POSIX:2001... " >&6; } if test ${gl_cv_header_locale_h_posix2001+y} then : @@ -34667,10 +34889,10 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_locale_h_posix2001" >&5 -printf "%s\n" "$gl_cv_header_locale_h_posix2001" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_locale_h_posix2001" >&5 +printf '%s\n' "$gl_cv_header_locale_h_posix2001" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether struct lconv is properly defined" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether struct lconv is properly defined" >&5 printf %s "checking whether struct lconv is properly defined... " >&6; } if test ${gl_cv_sys_struct_lconv_ok+y} then : @@ -34701,8 +34923,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_lconv_ok" >&5 -printf "%s\n" "$gl_cv_sys_struct_lconv_ok" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_lconv_ok" >&5 +printf '%s\n' "$gl_cv_sys_struct_lconv_ok" >&6; } if test $gl_cv_sys_struct_lconv_ok = no; then case "$host_os" in windows*-msvc*) @@ -34742,7 +34964,7 @@ rm -rf conftest* if test $gl_cv_have_include_next = yes; then gl_cv_next_locale_h='<'locale.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_locale_h+y} then : @@ -34787,8 +35009,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_locale_h" >&5 -printf "%s\n" "$gl_cv_next_locale_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_locale_h" >&5 +printf '%s\n' "$gl_cv_next_locale_h" >&6; } fi NEXT_LOCALE_H=$gl_cv_next_locale_h @@ -34832,7 +35054,7 @@ printf "%s\n" "$gl_cv_next_locale_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LC_MESSAGES" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for LC_MESSAGES" >&5 printf %s "checking for LC_MESSAGES... " >&6; } if test ${gt_cv_val_LC_MESSAGES+y} then : @@ -34860,11 +35082,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_val_LC_MESSAGES" >&5 -printf "%s\n" "$gt_cv_val_LC_MESSAGES" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_val_LC_MESSAGES" >&5 +printf '%s\n' "$gt_cv_val_LC_MESSAGES" >&6; } if test $gt_cv_val_LC_MESSAGES = yes; then -printf "%s\n" "@%:@define HAVE_LC_MESSAGES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_LC_MESSAGES 1" >>confdefs.h fi @@ -34879,7 +35101,7 @@ printf "%s\n" "@%:@define HAVE_LC_MESSAGES 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uselocale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for uselocale" >&5 printf %s "checking for uselocale... " >&6; } if test ${gl_cv_onwards_func_uselocale+y} then : @@ -34892,7 +35114,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "uselocale" "ac_cv_have_decl_uselocale" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_uselocale" = xyes then : @@ -34932,8 +35154,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_uselocale" >&5 -printf "%s\n" "$gl_cv_onwards_func_uselocale" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_uselocale" >&5 +printf '%s\n' "$gl_cv_onwards_func_uselocale" >&6; } case "$gl_cv_onwards_func_uselocale" in future*) ac_cv_func_uselocale=no ;; @@ -34941,7 +35163,7 @@ printf "%s\n" "$gl_cv_onwards_func_uselocale" >&6; } esac if test $ac_cv_func_uselocale = yes; then -printf "%s\n" "@%:@define HAVE_USELOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_USELOCALE 1" >>confdefs.h fi @@ -34949,7 +35171,7 @@ printf "%s\n" "@%:@define HAVE_USELOCALE 1" >>confdefs.h if test $ac_cv_func_uselocale = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether uselocale works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether uselocale works" >&5 printf %s "checking whether uselocale works... " >&6; } if test ${gt_cv_func_uselocale_works+y} then : @@ -34994,8 +35216,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_uselocale_works" >&5 -printf "%s\n" "$gt_cv_func_uselocale_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_uselocale_works" >&5 +printf '%s\n' "$gt_cv_func_uselocale_works" >&6; } else gt_cv_func_uselocale_works=no fi @@ -35003,7 +35225,7 @@ printf "%s\n" "$gt_cv_func_uselocale_works" >&6; } *yes) gt_working_uselocale=yes -printf "%s\n" "@%:@define HAVE_WORKING_USELOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WORKING_USELOCALE 1" >>confdefs.h ;; *) @@ -35015,7 +35237,7 @@ printf "%s\n" "@%:@define HAVE_WORKING_USELOCALE 1" >>confdefs.h case "$gt_cv_func_uselocale_works" in *yes) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fake locale system (OpenBSD)" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for fake locale system (OpenBSD)" >&5 printf %s "checking for fake locale system (OpenBSD)... " >&6; } if test ${gt_cv_locale_fake+y} then : @@ -35061,8 +35283,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fake" >&5 -printf "%s\n" "$gt_cv_locale_fake" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_fake" >&5 +printf '%s\n' "$gt_cv_locale_fake" >&6; } ;; *) gt_cv_locale_fake=no ;; esac @@ -35070,7 +35292,7 @@ printf "%s\n" "$gt_cv_locale_fake" >&6; } *yes) gt_fake_locales=yes -printf "%s\n" "@%:@define HAVE_FAKE_LOCALES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FAKE_LOCALES 1" >>confdefs.h ;; *) @@ -35080,7 +35302,7 @@ printf "%s\n" "@%:@define HAVE_FAKE_LOCALES 1" >>confdefs.h case "$gt_cv_func_uselocale_works" in *yes) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Solaris 11.4 locale system" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for Solaris 11.4 locale system" >&5 printf %s "checking for Solaris 11.4 locale system... " >&6; } if test ${gt_cv_locale_solaris114+y} then : @@ -35117,14 +35339,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_solaris114" >&5 -printf "%s\n" "$gt_cv_locale_solaris114" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_solaris114" >&5 +printf '%s\n' "$gt_cv_locale_solaris114" >&6; } ;; *) gt_cv_locale_solaris114=no ;; esac if test $gt_cv_locale_solaris114 = yes; then -printf "%s\n" "@%:@define HAVE_SOLARIS114_LOCALES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_SOLARIS114_LOCALES 1" >>confdefs.h fi @@ -35133,7 +35355,7 @@ printf "%s\n" "@%:@define HAVE_SOLARIS114_LOCALES 1" >>confdefs.h ac_fn_c_check_func "$LINENO" "getlocalename_l" "ac_cv_func_getlocalename_l" if test "x$ac_cv_func_getlocalename_l" = xyes then : - printf "%s\n" "@%:@define HAVE_GETLOCALENAME_L 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_GETLOCALENAME_L 1" >>confdefs.h fi @@ -35145,9 +35367,9 @@ fi aix*) gt_nameless_locales=yes -printf "%s\n" "@%:@define HAVE_NAMELESS_LOCALES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_NAMELESS_LOCALES 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AIX locales with LC_MESSAGES name" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for AIX locales with LC_MESSAGES name" >&5 printf %s "checking for AIX locales with LC_MESSAGES name... " >&6; } if test ${gt_cv_locale_aix72+y} then : @@ -35180,11 +35402,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_aix72" >&5 -printf "%s\n" "$gt_cv_locale_aix72" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_locale_aix72" >&5 +printf '%s\n' "$gt_cv_locale_aix72" >&6; } if test $gt_cv_locale_aix72 = yes; then -printf "%s\n" "@%:@define HAVE_AIX72_LOCALES 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_AIX72_LOCALES 1" >>confdefs.h fi ;; @@ -35193,7 +35415,7 @@ printf "%s\n" "@%:@define HAVE_AIX72_LOCALES 1" >>confdefs.h if test $gt_working_uselocale = yes && test $gt_fake_locales = no; then gt_good_uselocale=yes -printf "%s\n" "@%:@define HAVE_GOOD_USELOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_GOOD_USELOCALE 1" >>confdefs.h else gt_good_uselocale=no @@ -35203,7 +35425,7 @@ printf "%s\n" "@%:@define HAVE_GOOD_USELOCALE 1" >>confdefs.h gt_localename_enhances_locale_funcs=yes LOCALENAME_ENHANCE_LOCALE_FUNCS=1 -printf "%s\n" "@%:@define LOCALENAME_ENHANCE_LOCALE_FUNCS 1" >>confdefs.h +printf '%s\n' "@%:@define LOCALENAME_ENHANCE_LOCALE_FUNCS 1" >>confdefs.h else gt_localename_enhances_locale_funcs=no @@ -35214,7 +35436,7 @@ printf "%s\n" "@%:@define LOCALENAME_ENHANCE_LOCALE_FUNCS 1" >>confdefs.h case "$host_os" in *-musl* | midipix*) -printf "%s\n" "@%:@define MUSL_LIBC 1" >>confdefs.h +printf '%s\n' "@%:@define MUSL_LIBC 1" >>confdefs.h ;; esac @@ -35229,7 +35451,7 @@ printf "%s\n" "@%:@define MUSL_LIBC 1" >>confdefs.h if test "$gl_use_threads" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 printf %s "checking whether imported symbols can be declared weak... " >&6; } if test ${gl_cv_have_weak+y} then : @@ -35333,12 +35555,12 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 -printf "%s\n" "$gl_cv_have_weak" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 +printf '%s\n' "$gl_cv_have_weak" >&6; } case "$gl_cv_have_weak" in *yes) -printf "%s\n" "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h ;; esac @@ -35445,7 +35667,7 @@ rm -rf conftest* if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then # The program links fine without libpthread. But it may actually # need to link with libpthread in order to create multiple threads. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -35486,8 +35708,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -35503,13 +35725,13 @@ then : case "$host_os" in solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) -printf "%s\n" "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h +printf '%s\n' "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h esac fi else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 printf %s "checking for pthread_kill in -lthr... " >&6; } if test ${ac_cv_lib_thr_pthread_kill+y} then : @@ -35550,8 +35772,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_thr_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_thr_pthread_kill" >&6; } if test "x$ac_cv_lib_thr_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -35568,7 +35790,7 @@ fi elif test $gl_pthread_api != yes; then # Some library is needed. Try libpthread and libc_r. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -35609,8 +35831,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : gl_pthread_api=yes @@ -35620,7 +35842,7 @@ fi if test $gl_pthread_api != yes; then # For FreeBSD 4. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 printf %s "checking for pthread_kill in -lc_r... " >&6; } if test ${ac_cv_lib_c_r_pthread_kill+y} then : @@ -35661,8 +35883,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_c_r_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_c_r_pthread_kill" >&6; } if test "x$ac_cv_lib_c_r_pthread_kill" = xyes then : gl_pthread_api=yes @@ -35674,15 +35896,15 @@ fi fi echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&5 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 printf %s "checking whether POSIX threads API is available... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 -printf "%s\n" "$gl_pthread_api" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 +printf '%s\n' "$gl_pthread_api" >&6; } if test $gl_pthread_api = yes; then -printf "%s\n" "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h fi @@ -35702,7 +35924,7 @@ then : SCHED_YIELD_LIB= else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 printf %s "checking for sched_yield in -lrt... " >&6; } if test ${ac_cv_lib_rt_sched_yield+y} then : @@ -35743,13 +35965,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_rt_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_rt_sched_yield" >&6; } if test "x$ac_cv_lib_rt_sched_yield" = xyes then : SCHED_YIELD_LIB=-lrt else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 printf %s "checking for sched_yield in -lposix4... " >&6; } if test ${ac_cv_lib_posix4_sched_yield+y} then : @@ -35790,8 +36012,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_posix4_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_posix4_sched_yield" >&6; } if test "x$ac_cv_lib_posix4_sched_yield" = xyes then : SCHED_YIELD_LIB=-lposix4 @@ -35818,22 +36040,22 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then gl_threads_api='isoc+posix' -printf "%s\n" "@%:@define USE_ISOC_AND_POSIX_THREADS 1" >>confdefs.h +printf '%s\n' "@%:@define USE_ISOC_AND_POSIX_THREADS 1" >>confdefs.h LIBTHREAD= LTLIBTHREAD= else gl_threads_api=posix -printf "%s\n" "@%:@define USE_POSIX_THREADS 1" >>confdefs.h +printf '%s\n' "@%:@define USE_POSIX_THREADS 1" >>confdefs.h if test -z "$LIBMULTITHREAD" && test -z "$LTLIBMULTITHREAD"; then -printf "%s\n" "@%:@define USE_POSIX_THREADS_FROM_LIBC 1" >>confdefs.h +printf '%s\n' "@%:@define USE_POSIX_THREADS_FROM_LIBC 1" >>confdefs.h else if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then -printf "%s\n" "@%:@define USE_POSIX_THREADS_WEAK 1" >>confdefs.h +printf '%s\n' "@%:@define USE_POSIX_THREADS_WEAK 1" >>confdefs.h LIBTHREAD= LTLIBTHREAD= else @@ -35841,7 +36063,7 @@ printf "%s\n" "@%:@define USE_POSIX_THREADS_WEAK 1" >>confdefs.h freebsd* | dragonfly* | midnightbsd*) if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then -printf "%s\n" "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h +printf '%s\n' "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h fi ;; @@ -35955,7 +36177,7 @@ rm -rf conftest* if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then # The program links fine without libpthread. But it may actually # need to link with libpthread in order to create multiple threads. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -35996,8 +36218,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -36013,13 +36235,13 @@ then : case "$host_os" in solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) -printf "%s\n" "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h +printf '%s\n' "@%:@define PTHREAD_IN_USE_DETECTION_HARD 1" >>confdefs.h esac fi else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lthr" >&5 printf %s "checking for pthread_kill in -lthr... " >&6; } if test ${ac_cv_lib_thr_pthread_kill+y} then : @@ -36060,8 +36282,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_thr_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_thr_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_thr_pthread_kill" >&6; } if test "x$ac_cv_lib_thr_pthread_kill" = xyes then : if test $gl_pthread_in_glibc = yes; then @@ -36078,7 +36300,7 @@ fi elif test $gl_pthread_api != yes; then # Some library is needed. Try libpthread and libc_r. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lpthread" >&5 printf %s "checking for pthread_kill in -lpthread... " >&6; } if test ${ac_cv_lib_pthread_pthread_kill+y} then : @@ -36119,8 +36341,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_pthread_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pthread_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_pthread_pthread_kill" >&6; } if test "x$ac_cv_lib_pthread_pthread_kill" = xyes then : gl_pthread_api=yes @@ -36130,7 +36352,7 @@ fi if test $gl_pthread_api != yes; then # For FreeBSD 4. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_kill in -lc_r" >&5 printf %s "checking for pthread_kill in -lc_r... " >&6; } if test ${ac_cv_lib_c_r_pthread_kill+y} then : @@ -36171,8 +36393,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 -printf "%s\n" "$ac_cv_lib_c_r_pthread_kill" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_r_pthread_kill" >&5 +printf '%s\n' "$ac_cv_lib_c_r_pthread_kill" >&6; } if test "x$ac_cv_lib_c_r_pthread_kill" = xyes then : gl_pthread_api=yes @@ -36184,15 +36406,15 @@ fi fi echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&5 fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether POSIX threads API is available" >&5 printf %s "checking whether POSIX threads API is available... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 -printf "%s\n" "$gl_pthread_api" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_pthread_api" >&5 +printf '%s\n' "$gl_pthread_api" >&6; } if test $gl_pthread_api = yes; then -printf "%s\n" "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_API 1" >>confdefs.h fi @@ -36212,7 +36434,7 @@ then : SCHED_YIELD_LIB= else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 printf %s "checking for sched_yield in -lrt... " >&6; } if test ${ac_cv_lib_rt_sched_yield+y} then : @@ -36253,13 +36475,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_rt_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_rt_sched_yield" >&6; } if test "x$ac_cv_lib_rt_sched_yield" = xyes then : SCHED_YIELD_LIB=-lrt else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 printf %s "checking for sched_yield in -lposix4... " >&6; } if test ${ac_cv_lib_posix4_sched_yield+y} then : @@ -36300,8 +36522,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_posix4_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_posix4_sched_yield" >&6; } if test "x$ac_cv_lib_posix4_sched_yield" = xyes then : SCHED_YIELD_LIB=-lposix4 @@ -36325,7 +36547,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ if test $ac_cv_header_threads_h = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for thrd_create" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for thrd_create" >&5 printf %s "checking for thrd_create... " >&6; } if test ${gl_cv_onwards_func_thrd_create+y} then : @@ -36338,7 +36560,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "thrd_create" "ac_cv_have_decl_thrd_create" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_thrd_create" = xyes then : @@ -36378,8 +36600,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_thrd_create" >&5 -printf "%s\n" "$gl_cv_onwards_func_thrd_create" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_thrd_create" >&5 +printf '%s\n' "$gl_cv_onwards_func_thrd_create" >&6; } case "$gl_cv_onwards_func_thrd_create" in future*) ac_cv_func_thrd_create=no ;; @@ -36387,7 +36609,7 @@ printf "%s\n" "$gl_cv_onwards_func_thrd_create" >&6; } esac if test $ac_cv_func_thrd_create = yes; then -printf "%s\n" "@%:@define HAVE_THRD_CREATE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_THRD_CREATE 1" >>confdefs.h fi @@ -36395,7 +36617,7 @@ printf "%s\n" "@%:@define HAVE_THRD_CREATE 1" >>confdefs.h if test $ac_cv_func_thrd_create = yes; then LIBSTDTHREAD= else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for thrd_create in -lstdthreads" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for thrd_create in -lstdthreads" >&5 printf %s "checking for thrd_create in -lstdthreads... " >&6; } if test ${ac_cv_lib_stdthreads_thrd_create+y} then : @@ -36436,8 +36658,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_stdthreads_thrd_create" >&5 -printf "%s\n" "$ac_cv_lib_stdthreads_thrd_create" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_stdthreads_thrd_create" >&5 +printf '%s\n' "$ac_cv_lib_stdthreads_thrd_create" >&6; } if test "x$ac_cv_lib_stdthreads_thrd_create" = xyes then : @@ -36458,10 +36680,10 @@ fi esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ISO C threads API is available" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ISO C threads API is available" >&5 printf %s "checking whether ISO C threads API is available... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_threads_h" >&5 -printf "%s\n" "$ac_cv_header_threads_h" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_threads_h" >&5 +printf '%s\n' "$ac_cv_header_threads_h" >&6; } gl_stdthreadlib_body_done=done fi @@ -36469,7 +36691,7 @@ printf "%s\n" "$ac_cv_header_threads_h" >&6; } LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD gl_threads_api=isoc -printf "%s\n" "@%:@define USE_ISOC_THREADS 1" >>confdefs.h +printf '%s\n' "@%:@define USE_ISOC_THREADS 1" >>confdefs.h fi fi @@ -36483,7 +36705,7 @@ printf "%s\n" "@%:@define USE_ISOC_THREADS 1" >>confdefs.h }; then gl_threads_api=windows -printf "%s\n" "@%:@define USE_WINDOWS_THREADS 1" >>confdefs.h +printf '%s\n' "@%:@define USE_WINDOWS_THREADS 1" >>confdefs.h fi ;; @@ -36491,13 +36713,13 @@ printf "%s\n" "@%:@define USE_WINDOWS_THREADS 1" >>confdefs.h fi else -printf "%s\n" "@%:@define AVOID_ANY_THREADS 1" >>confdefs.h +printf '%s\n' "@%:@define AVOID_ANY_THREADS 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for multithread API to use" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for multithread API to use" >&5 printf %s "checking for multithread API to use... " >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_threads_api" >&5 -printf "%s\n" "$gl_threads_api" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_threads_api" >&5 +printf '%s\n' "$gl_threads_api" >&6; } @@ -36509,7 +36731,7 @@ printf "%s\n" "$gl_threads_api" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether malloc (0) returns nonnull" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether malloc (0) returns nonnull" >&5 printf %s "checking whether malloc (0) returns nonnull... " >&6; } if test ${ac_cv_func_malloc_0_nonnull+y} then : @@ -36560,8 +36782,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5 -printf "%s\n" "$ac_cv_func_malloc_0_nonnull" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5 +printf '%s\n' "$ac_cv_func_malloc_0_nonnull" >&6; } case $ac_cv_func_malloc_0_nonnull in @%:@( *yes) : gl_cv_func_malloc_0_nonnull=1 ;; @%:@( @@ -36570,7 +36792,7 @@ printf "%s\n" "$ac_cv_func_malloc_0_nonnull" >&6; } esac -printf "%s\n" "@%:@define MALLOC_0_IS_NONNULL $gl_cv_func_malloc_0_nonnull" >>confdefs.h +printf '%s\n' "@%:@define MALLOC_0_IS_NONNULL $gl_cv_func_malloc_0_nonnull" >>confdefs.h @@ -36997,7 +37219,7 @@ fi # Try to allow MAP_ANONYMOUS. gl_have_mmap_anonymous=no if test $gl_have_mmap = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MAP_ANONYMOUS" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for MAP_ANONYMOUS" >&5 printf %s "checking for MAP_ANONYMOUS... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -37029,18 +37251,18 @@ if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP_TRADITIONAL "I cannot identify this map" >/dev/null 2>&1 then : -printf "%s\n" "@%:@define MAP_ANONYMOUS MAP_ANON" >>confdefs.h +printf '%s\n' "@%:@define MAP_ANONYMOUS MAP_ANON" >>confdefs.h gl_have_mmap_anonymous=yes fi rm -rf conftest* fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_have_mmap_anonymous" >&5 -printf "%s\n" "$gl_have_mmap_anonymous" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_have_mmap_anonymous" >&5 +printf '%s\n' "$gl_have_mmap_anonymous" >&6; } if test $gl_have_mmap_anonymous = yes; then -printf "%s\n" "@%:@define HAVE_MAP_ANONYMOUS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MAP_ANONYMOUS 1" >>confdefs.h fi fi @@ -37063,7 +37285,7 @@ printf "%s\n" "@%:@define HAVE_MAP_ANONYMOUS 1" >>confdefs.h # memchr should cast the second argument to 'unsigned char'. # This bug exists in Android 4.3. # Assume that memchr works on platforms that lack mprotect. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether memchr works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether memchr works" >&5 printf %s "checking whether memchr works... " >&6; } if test ${gl_cv_func_memchr_works+y} then : @@ -37164,8 +37386,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_memchr_works" >&5 -printf "%s\n" "$gl_cv_func_memchr_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_memchr_works" >&5 +printf '%s\n' "$gl_cv_func_memchr_works" >&6; } case "$gl_cv_func_memchr_works" in *yes) ;; *) REPLACE_MEMCHR=1 ;; @@ -37175,7 +37397,7 @@ printf "%s\n" "$gl_cv_func_memchr_works" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether defines MIN and MAX" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether defines MIN and MAX" >&5 printf %s "checking whether defines MIN and MAX... " >&6; } if test ${gl_cv_minmax_in_limits_h+y} then : @@ -37203,11 +37425,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_minmax_in_limits_h" >&5 -printf "%s\n" "$gl_cv_minmax_in_limits_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_minmax_in_limits_h" >&5 +printf '%s\n' "$gl_cv_minmax_in_limits_h" >&6; } if test $gl_cv_minmax_in_limits_h = yes; then -printf "%s\n" "@%:@define HAVE_MINMAX_IN_LIMITS_H 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MINMAX_IN_LIMITS_H 1" >>confdefs.h fi @@ -37216,7 +37438,7 @@ printf "%s\n" "@%:@define HAVE_MINMAX_IN_LIMITS_H 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether defines MIN and MAX" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether defines MIN and MAX" >&5 printf %s "checking whether defines MIN and MAX... " >&6; } if test ${gl_cv_minmax_in_sys_param_h+y} then : @@ -37244,11 +37466,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_minmax_in_sys_param_h" >&5 -printf "%s\n" "$gl_cv_minmax_in_sys_param_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_minmax_in_sys_param_h" >&5 +printf '%s\n' "$gl_cv_minmax_in_sys_param_h" >&6; } if test $gl_cv_minmax_in_sys_param_h = yes; then -printf "%s\n" "@%:@define HAVE_MINMAX_IN_SYS_PARAM_H 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MINMAX_IN_SYS_PARAM_H 1" >>confdefs.h fi @@ -37259,7 +37481,7 @@ printf "%s\n" "@%:@define HAVE_MINMAX_IN_SYS_PARAM_H 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for O_CLOEXEC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for O_CLOEXEC" >&5 printf %s "checking for O_CLOEXEC... " >&6; } if test ${gl_cv_macro_O_CLOEXEC+y} then : @@ -37290,12 +37512,12 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_macro_O_CLOEXEC" >&5 -printf "%s\n" "$gl_cv_macro_O_CLOEXEC" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_macro_O_CLOEXEC" >&5 +printf '%s\n' "$gl_cv_macro_O_CLOEXEC" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for promoted mode_t type" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for promoted mode_t type" >&5 printf %s "checking for promoted mode_t type... " >&6; } if test ${gl_cv_promoted_mode_t+y} then : @@ -37324,10 +37546,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_promoted_mode_t" >&5 -printf "%s\n" "$gl_cv_promoted_mode_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_promoted_mode_t" >&5 +printf '%s\n' "$gl_cv_promoted_mode_t" >&6; } -printf "%s\n" "@%:@define PROMOTED_MODE_T $gl_cv_promoted_mode_t" >>confdefs.h +printf '%s\n' "@%:@define PROMOTED_MODE_T $gl_cv_promoted_mode_t" >>confdefs.h @@ -37355,7 +37577,7 @@ printf "%s\n" "@%:@define PROMOTED_MODE_T $gl_cv_promoted_mode_t" >>confdefs.h if test "x$ac_cv_type_sigset_t" = xyes then : -printf "%s\n" "@%:@define HAVE_SIGSET_T 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_SIGSET_T 1" >>confdefs.h gl_cv_type_sigset_t=yes else case e in @%:@( @@ -37369,7 +37591,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SIGPIPE" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for SIGPIPE" >&5 printf %s "checking for SIGPIPE... " >&6; } if test ${gl_cv_header_signal_h_SIGPIPE+y} then : @@ -37398,8 +37620,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_signal_h_SIGPIPE" >&5 -printf "%s\n" "$gl_cv_header_signal_h_SIGPIPE" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_signal_h_SIGPIPE" >&5 +printf '%s\n' "$gl_cv_header_signal_h_SIGPIPE" >&6; } @@ -37432,7 +37654,7 @@ printf "%s\n" "$gl_cv_header_signal_h_SIGPIPE" >&6; } fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shared library path variable" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shared library path variable" >&5 printf %s "checking for shared library path variable... " >&6; } if test ${acl_cv_libpath+y} then : @@ -37447,12 +37669,12 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libpath" >&5 -printf "%s\n" "$acl_cv_libpath" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libpath" >&5 +printf '%s\n' "$acl_cv_libpath" >&6; } shlibpath_var="$acl_cv_shlibpath_var" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to activate relocatable installation" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to activate relocatable installation" >&5 printf %s "checking whether to activate relocatable installation... " >&6; } @%:@ Check whether --enable-relocatable was given. if test ${enable_relocatable+y} @@ -37469,8 +37691,8 @@ esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RELOCATABLE" >&5 -printf "%s\n" "$RELOCATABLE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RELOCATABLE" >&5 +printf '%s\n' "$RELOCATABLE" >&6; } @@ -37480,11 +37702,13 @@ printf "%s\n" "$RELOCATABLE" >&6; } reloc_final_prefix="$prefix" fi -printf "%s\n" "@%:@define INSTALLPREFIX \"${reloc_final_prefix}\"" >>confdefs.h +cat >>confdefs.h <<_ACEOF +@%:@define INSTALLPREFIX "${reloc_final_prefix}" +_ACEOF if test $RELOCATABLE = yes; then -printf "%s\n" "@%:@define ENABLE_RELOCATABLE 1" >>confdefs.h +printf '%s\n' "@%:@define ENABLE_RELOCATABLE 1" >>confdefs.h fi @@ -37505,14 +37729,14 @@ printf "%s\n" "@%:@define ENABLE_RELOCATABLE 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "mach-o/dyld.h" "ac_cv_header_mach_o_dyld_h" "$ac_includes_default" if test "x$ac_cv_header_mach_o_dyld_h" = xyes then : - printf "%s\n" "@%:@define HAVE_MACH_O_DYLD_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_MACH_O_DYLD_H 1" >>confdefs.h fi ac_fn_c_check_func "$LINENO" "_NSGetExecutablePath" "ac_cv_func__NSGetExecutablePath" if test "x$ac_cv_func__NSGetExecutablePath" = xyes then : - printf "%s\n" "@%:@define HAVE__NSGETEXECUTABLEPATH 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE__NSGETEXECUTABLEPATH 1" >>confdefs.h fi @@ -37531,7 +37755,7 @@ fi ac_fn_c_check_func "$LINENO" "copy_file_range" "ac_cv_func_copy_file_range" if test "x$ac_cv_func_copy_file_range" = xyes then : - printf "%s\n" "@%:@define HAVE_COPY_FILE_RANGE 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_COPY_FILE_RANGE 1" >>confdefs.h fi @@ -37615,7 +37839,7 @@ fi RELOCATABLE_STRIP=':' -ac_fn_check_decl "$LINENO" "setenv" "ac_cv_have_decl_setenv" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "setenv" "ac_cv_have_decl_setenv" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_setenv" = xyes then : ac_have_decl=1 @@ -37623,7 +37847,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_SETENV $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_SETENV $ac_have_decl" >>confdefs.h ac_fn_c_check_type "$LINENO" "uid_t" "ac_cv_type_uid_t" "$ac_includes_default" @@ -37632,7 +37856,7 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define uid_t int" >>confdefs.h +printf '%s\n' "@%:@define uid_t int" >>confdefs.h ;; esac fi @@ -37643,7 +37867,7 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define gid_t int" >>confdefs.h +printf '%s\n' "@%:@define gid_t int" >>confdefs.h ;; esac fi @@ -37662,7 +37886,7 @@ fi if test $gl_cv_have_include_next = yes; then gl_cv_next_signal_h='<'signal.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_signal_h+y} then : @@ -37707,8 +37931,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_signal_h" >&5 -printf "%s\n" "$gl_cv_next_signal_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_signal_h" >&5 +printf '%s\n' "$gl_cv_next_signal_h" >&6; } fi NEXT_SIGNAL_H=$gl_cv_next_signal_h @@ -38078,7 +38302,7 @@ then : { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null 2>&1 if test -f conftest.o; then gl_asmext='s' @@ -38101,7 +38325,7 @@ rm -rf conftest* - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether C symbols are prefixed with underscore at the linker level" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether C symbols are prefixed with underscore at the linker level" >&5 printf %s "checking whether C symbols are prefixed with underscore at the linker level... " >&6; } if test ${gl_cv_prog_as_underscore+y} then : @@ -38118,7 +38342,7 @@ EOF { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null 2>&1 if LC_ALL=C $EGREP '(^|[^a-zA-Z0-9_])_foo([^a-zA-Z0-9_]|$)' conftest.$gl_asmext >/dev/null; then gl_cv_prog_as_underscore=yes @@ -38129,15 +38353,15 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_as_underscore" >&5 -printf "%s\n" "$gl_cv_prog_as_underscore" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_as_underscore" >&5 +printf '%s\n' "$gl_cv_prog_as_underscore" >&6; } if test $gl_cv_prog_as_underscore = yes; then USER_LABEL_PREFIX=_ else USER_LABEL_PREFIX= fi -printf "%s\n" "@%:@define USER_LABEL_PREFIX $USER_LABEL_PREFIX" >>confdefs.h +printf '%s\n' "@%:@define USER_LABEL_PREFIX $USER_LABEL_PREFIX" >>confdefs.h ASM_SYMBOL_PREFIX='"'${USER_LABEL_PREFIX}'"' @@ -38147,7 +38371,7 @@ printf "%s\n" "@%:@define USER_LABEL_PREFIX $USER_LABEL_PREFIX" >>confdefs.h -ac_fn_check_decl "$LINENO" "fcloseall" "ac_cv_have_decl_fcloseall" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fcloseall" "ac_cv_have_decl_fcloseall" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fcloseall" = xyes then : ac_have_decl=1 @@ -38155,9 +38379,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FCLOSEALL $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FCLOSEALL $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "getw" "ac_cv_have_decl_getw" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "getw" "ac_cv_have_decl_getw" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_getw" = xyes then : ac_have_decl=1 @@ -38165,9 +38389,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_GETW $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_GETW $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "putw" "ac_cv_have_decl_putw" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "putw" "ac_cv_have_decl_putw" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_putw" = xyes then : ac_have_decl=1 @@ -38175,7 +38399,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PUTW $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PUTW $ac_have_decl" >>confdefs.h @@ -38190,7 +38414,7 @@ printf "%s\n" "@%:@define HAVE_DECL_PUTW $ac_have_decl" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_stdio_h='<'stdio.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_stdio_h+y} then : @@ -38235,8 +38459,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdio_h" >&5 -printf "%s\n" "$gl_cv_next_stdio_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdio_h" >&5 +printf '%s\n' "$gl_cv_next_stdio_h" >&6; } fi NEXT_STDIO_H=$gl_cv_next_stdio_h @@ -38253,7 +38477,7 @@ printf "%s\n" "$gl_cv_next_stdio_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which flavor of printf attribute matches inttypes macros" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which flavor of printf attribute matches inttypes macros" >&5 printf %s "checking which flavor of printf attribute matches inttypes macros... " >&6; } if test ${gl_cv_func_printf_attribute_flavor+y} then : @@ -38291,11 +38515,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_printf_attribute_flavor" >&5 -printf "%s\n" "$gl_cv_func_printf_attribute_flavor" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_printf_attribute_flavor" >&5 +printf '%s\n' "$gl_cv_func_printf_attribute_flavor" >&6; } if test "$gl_cv_func_printf_attribute_flavor" = gnu; then -printf "%s\n" "@%:@define GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU 1" >>confdefs.h fi @@ -38334,7 +38558,7 @@ printf "%s\n" "@%:@define GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU 1" >>confdefs.h HAVE_DECL_PUTW=0 fi -ac_fn_check_decl "$LINENO" "ecvt" "ac_cv_have_decl_ecvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "ecvt" "ac_cv_have_decl_ecvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_ecvt" = xyes then : ac_have_decl=1 @@ -38342,9 +38566,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_ECVT $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_ECVT $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fcvt" "ac_cv_have_decl_fcvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fcvt" "ac_cv_have_decl_fcvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fcvt" = xyes then : ac_have_decl=1 @@ -38352,9 +38576,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FCVT $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FCVT $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "gcvt" "ac_cv_have_decl_gcvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "gcvt" "ac_cv_have_decl_gcvt" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_gcvt" = xyes then : ac_have_decl=1 @@ -38362,7 +38586,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_GCVT $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_GCVT $ac_have_decl" >>confdefs.h @@ -38377,7 +38601,7 @@ printf "%s\n" "@%:@define HAVE_DECL_GCVT $ac_have_decl" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_stdlib_h='<'stdlib.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_stdlib_h+y} then : @@ -38422,8 +38646,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdlib_h" >&5 -printf "%s\n" "$gl_cv_next_stdlib_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_stdlib_h" >&5 +printf '%s\n' "$gl_cv_next_stdlib_h" >&6; } fi NEXT_STDLIB_H=$gl_cv_next_stdlib_h @@ -38448,7 +38672,7 @@ printf "%s\n" "$gl_cv_next_stdlib_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether MB_CUR_MAX is correct" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether MB_CUR_MAX is correct" >&5 printf %s "checking whether MB_CUR_MAX is correct... " >&6; } if test ${gl_cv_macro_MB_CUR_MAX_good+y} then : @@ -38498,8 +38722,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_macro_MB_CUR_MAX_good" >&5 -printf "%s\n" "$gl_cv_macro_MB_CUR_MAX_good" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_macro_MB_CUR_MAX_good" >&5 +printf '%s\n' "$gl_cv_macro_MB_CUR_MAX_good" >&6; } case "$gl_cv_macro_MB_CUR_MAX_good" in *yes) ;; *) REPLACE_MB_CUR_MAX=1 ;; @@ -38520,7 +38744,7 @@ printf "%s\n" "$gl_cv_macro_MB_CUR_MAX_good" >&6; } REPLACE_STRERROR_0=0 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether strerror(0) succeeds" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether strerror(0) succeeds" >&5 printf %s "checking whether strerror(0) succeeds... " >&6; } if test ${gl_cv_func_strerror_0_works+y} then : @@ -38576,14 +38800,14 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_strerror_0_works" >&5 -printf "%s\n" "$gl_cv_func_strerror_0_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_strerror_0_works" >&5 +printf '%s\n' "$gl_cv_func_strerror_0_works" >&6; } case "$gl_cv_func_strerror_0_works" in *yes) ;; *) REPLACE_STRERROR_0=1 -printf "%s\n" "@%:@define REPLACE_STRERROR_0 1" >>confdefs.h +printf '%s\n' "@%:@define REPLACE_STRERROR_0 1" >>confdefs.h ;; esac @@ -38601,7 +38825,7 @@ printf "%s\n" "@%:@define REPLACE_STRERROR_0 1" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_string_h='<'string.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_string_h+y} then : @@ -38646,8 +38870,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_string_h" >&5 -printf "%s\n" "$gl_cv_next_string_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_string_h" >&5 +printf '%s\n' "$gl_cv_next_string_h" >&6; } fi NEXT_STRING_H=$gl_cv_next_string_h @@ -38670,7 +38894,7 @@ printf "%s\n" "$gl_cv_next_string_h" >&6; } -ac_fn_check_decl "$LINENO" "strnlen" "ac_cv_have_decl_strnlen" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "strnlen" "ac_cv_have_decl_strnlen" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_strnlen" = xyes then : ac_have_decl=1 @@ -38678,7 +38902,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_STRNLEN $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_STRNLEN $ac_have_decl" >>confdefs.h @@ -38692,7 +38916,7 @@ printf "%s\n" "@%:@define HAVE_DECL_STRNLEN $ac_have_decl" >>confdefs.h -printf "%s\n" "@%:@define _USE_STD_STAT 1" >>confdefs.h +printf '%s\n' "@%:@define _USE_STD_STAT 1" >>confdefs.h @@ -38706,7 +38930,7 @@ printf "%s\n" "@%:@define _USE_STD_STAT 1" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_sys_types_h='<'sys/types.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_sys_types_h+y} then : @@ -38751,8 +38975,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_types_h" >&5 -printf "%s\n" "$gl_cv_next_sys_types_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_sys_types_h" >&5 +printf '%s\n' "$gl_cv_next_sys_types_h" >&6; } fi NEXT_SYS_TYPES_H=$gl_cv_next_sys_types_h @@ -38805,7 +39029,7 @@ printf "%s\n" "$gl_cv_next_sys_types_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 printf %s "checking for struct timespec in ... " >&6; } if test ${gl_cv_sys_struct_timespec_in_time_h+y} then : @@ -38833,8 +39057,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_time_h" >&5 -printf "%s\n" "$gl_cv_sys_struct_timespec_in_time_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_time_h" >&5 +printf '%s\n' "$gl_cv_sys_struct_timespec_in_time_h" >&6; } TIME_H_DEFINES_STRUCT_TIMESPEC=0 SYS_TIME_H_DEFINES_STRUCT_TIMESPEC=0 @@ -38843,7 +39067,7 @@ printf "%s\n" "$gl_cv_sys_struct_timespec_in_time_h" >&6; } if test $gl_cv_sys_struct_timespec_in_time_h = yes; then TIME_H_DEFINES_STRUCT_TIMESPEC=1 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 printf %s "checking for struct timespec in ... " >&6; } if test ${gl_cv_sys_struct_timespec_in_sys_time_h+y} then : @@ -38871,12 +39095,12 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_sys_time_h" >&5 -printf "%s\n" "$gl_cv_sys_struct_timespec_in_sys_time_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_sys_time_h" >&5 +printf '%s\n' "$gl_cv_sys_struct_timespec_in_sys_time_h" >&6; } if test $gl_cv_sys_struct_timespec_in_sys_time_h = yes; then SYS_TIME_H_DEFINES_STRUCT_TIMESPEC=1 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 printf %s "checking for struct timespec in ... " >&6; } if test ${gl_cv_sys_struct_timespec_in_pthread_h+y} then : @@ -38904,12 +39128,12 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_pthread_h" >&5 -printf "%s\n" "$gl_cv_sys_struct_timespec_in_pthread_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_pthread_h" >&5 +printf '%s\n' "$gl_cv_sys_struct_timespec_in_pthread_h" >&6; } if test $gl_cv_sys_struct_timespec_in_pthread_h = yes; then PTHREAD_H_DEFINES_STRUCT_TIMESPEC=1 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for struct timespec in " >&5 printf %s "checking for struct timespec in ... " >&6; } if test ${gl_cv_sys_struct_timespec_in_unistd_h+y} then : @@ -38937,8 +39161,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_unistd_h" >&5 -printf "%s\n" "$gl_cv_sys_struct_timespec_in_unistd_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_sys_struct_timespec_in_unistd_h" >&5 +printf '%s\n' "$gl_cv_sys_struct_timespec_in_unistd_h" >&6; } if test $gl_cv_sys_struct_timespec_in_unistd_h = yes; then UNISTD_H_DEFINES_STRUCT_TIMESPEC=1 fi @@ -38964,7 +39188,7 @@ printf "%s\n" "$gl_cv_sys_struct_timespec_in_unistd_h" >&6; } if test $gl_cv_have_include_next = yes; then gl_cv_next_time_h='<'time.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_time_h+y} then : @@ -39009,8 +39233,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_time_h" >&5 -printf "%s\n" "$gl_cv_next_time_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_time_h" >&5 +printf '%s\n' "$gl_cv_next_time_h" >&6; } fi NEXT_TIME_H=$gl_cv_next_time_h @@ -39034,7 +39258,7 @@ printf "%s\n" "$gl_cv_next_time_h" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TIME_UTC in " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for TIME_UTC in " >&5 printf %s "checking for TIME_UTC in ... " >&6; } if test ${gl_cv_time_h_has_TIME_UTC+y} then : @@ -39062,8 +39286,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_time_h_has_TIME_UTC" >&5 -printf "%s\n" "$gl_cv_time_h_has_TIME_UTC" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_time_h_has_TIME_UTC" >&5 +printf '%s\n' "$gl_cv_time_h_has_TIME_UTC" >&6; } if test $gl_cv_time_h_has_TIME_UTC = yes; then TIME_H_DEFINES_TIME_UTC=1 else @@ -39164,7 +39388,7 @@ do : ac_fn_c_check_header_compile "$LINENO" "unistring/woe32dll.h" "ac_cv_header_unistring_woe32dll_h" "$ac_includes_default" if test "x$ac_cv_header_unistring_woe32dll_h" = xyes then : - printf "%s\n" "@%:@define HAVE_UNISTRING_WOE32DLL_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_UNISTRING_WOE32DLL_H 1" >>confdefs.h HAVE_UNISTRING_WOE32DLL_H=1 else case e in @%:@( e) HAVE_UNISTRING_WOE32DLL_H=0 ;; @@ -39763,7 +39987,7 @@ done -ac_fn_check_decl "$LINENO" "execvpe" "ac_cv_have_decl_execvpe" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "execvpe" "ac_cv_have_decl_execvpe" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_execvpe" = xyes then : ac_have_decl=1 @@ -39771,7 +39995,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_EXECVPE $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_EXECVPE $ac_have_decl" >>confdefs.h @@ -39788,7 +40012,7 @@ printf "%s\n" "@%:@define HAVE_DECL_EXECVPE $ac_have_decl" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_unistd_h='<'unistd.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_unistd_h+y} then : @@ -39839,8 +40063,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_unistd_h" >&5 -printf "%s\n" "$gl_cv_next_unistd_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_unistd_h" >&5 +printf '%s\n' "$gl_cv_next_unistd_h" >&6; } fi NEXT_UNISTD_H=$gl_cv_next_unistd_h @@ -39878,7 +40102,7 @@ printf "%s\n" "$gl_cv_next_unistd_h" >&6; } HAVE_DECL_EXECVPE=0 fi -ac_fn_check_decl "$LINENO" "clearerr_unlocked" "ac_cv_have_decl_clearerr_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "clearerr_unlocked" "ac_cv_have_decl_clearerr_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_clearerr_unlocked" = xyes then : ac_have_decl=1 @@ -39886,9 +40110,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_CLEARERR_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_CLEARERR_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "feof_unlocked" "ac_cv_have_decl_feof_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "feof_unlocked" "ac_cv_have_decl_feof_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_feof_unlocked" = xyes then : ac_have_decl=1 @@ -39896,9 +40120,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FEOF_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FEOF_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "ferror_unlocked" "ac_cv_have_decl_ferror_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "ferror_unlocked" "ac_cv_have_decl_ferror_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_ferror_unlocked" = xyes then : ac_have_decl=1 @@ -39906,9 +40130,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FERROR_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FERROR_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fflush_unlocked" "ac_cv_have_decl_fflush_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fflush_unlocked" "ac_cv_have_decl_fflush_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fflush_unlocked" = xyes then : ac_have_decl=1 @@ -39916,9 +40140,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FFLUSH_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FFLUSH_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fgets_unlocked" "ac_cv_have_decl_fgets_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fgets_unlocked" "ac_cv_have_decl_fgets_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fgets_unlocked" = xyes then : ac_have_decl=1 @@ -39926,9 +40150,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FGETS_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FGETS_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fputc_unlocked" "ac_cv_have_decl_fputc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fputc_unlocked" "ac_cv_have_decl_fputc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fputc_unlocked" = xyes then : ac_have_decl=1 @@ -39936,9 +40160,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FPUTC_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FPUTC_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fputs_unlocked" "ac_cv_have_decl_fputs_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fputs_unlocked" "ac_cv_have_decl_fputs_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fputs_unlocked" = xyes then : ac_have_decl=1 @@ -39946,9 +40170,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FPUTS_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FPUTS_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fread_unlocked" "ac_cv_have_decl_fread_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fread_unlocked" "ac_cv_have_decl_fread_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fread_unlocked" = xyes then : ac_have_decl=1 @@ -39956,9 +40180,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FREAD_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FREAD_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "fwrite_unlocked" "ac_cv_have_decl_fwrite_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "fwrite_unlocked" "ac_cv_have_decl_fwrite_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_fwrite_unlocked" = xyes then : ac_have_decl=1 @@ -39966,9 +40190,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_FWRITE_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_FWRITE_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "getc_unlocked" "ac_cv_have_decl_getc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "getc_unlocked" "ac_cv_have_decl_getc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_getc_unlocked" = xyes then : ac_have_decl=1 @@ -39976,9 +40200,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_GETC_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_GETC_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "getchar_unlocked" "ac_cv_have_decl_getchar_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "getchar_unlocked" "ac_cv_have_decl_getchar_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_getchar_unlocked" = xyes then : ac_have_decl=1 @@ -39986,9 +40210,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_GETCHAR_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_GETCHAR_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "putc_unlocked" "ac_cv_have_decl_putc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "putc_unlocked" "ac_cv_have_decl_putc_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_putc_unlocked" = xyes then : ac_have_decl=1 @@ -39996,9 +40220,9 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PUTC_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PUTC_UNLOCKED $ac_have_decl" >>confdefs.h -ac_fn_check_decl "$LINENO" "putchar_unlocked" "ac_cv_have_decl_putchar_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS" +ac_fn_check_decl "$LINENO" "putchar_unlocked" "ac_cv_have_decl_putchar_unlocked" "$ac_includes_default" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_putchar_unlocked" = xyes then : ac_have_decl=1 @@ -40006,11 +40230,11 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PUTCHAR_UNLOCKED $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PUTCHAR_UNLOCKED $ac_have_decl" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether uses 'inline' correctly" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether uses 'inline' correctly" >&5 printf %s "checking whether uses 'inline' correctly... " >&6; } if test ${gl_cv_header_wchar_h_correct_inline+y} then : @@ -40035,7 +40259,7 @@ _ACEOF && { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -40051,7 +40275,7 @@ _ACEOF && { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 (eval $ac_compile) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then if $CC -o conftest$ac_exeext $CFLAGS $LDFLAGS conftest1.$ac_objext conftest2.$ac_objext $LIBS >&5 2>&1; then : @@ -40067,8 +40291,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_wchar_h_correct_inline" >&5 -printf "%s\n" "$gl_cv_header_wchar_h_correct_inline" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_wchar_h_correct_inline" >&5 +printf '%s\n' "$gl_cv_header_wchar_h_correct_inline" >&6; } if test $gl_cv_header_wchar_h_correct_inline = no; then as_fn_error $? " cannot be used with this compiler ($CC $CFLAGS $CPPFLAGS). This is a known interoperability problem of glibc <= 2.5 with gcc >= 4.3 in @@ -40106,7 +40330,7 @@ Configuration aborted." "$LINENO" 5 if test $gl_cv_have_include_next = yes; then gl_cv_next_wchar_h='<'wchar.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_wchar_h+y} then : @@ -40157,8 +40381,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_wchar_h" >&5 -printf "%s\n" "$gl_cv_next_wchar_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_wchar_h" >&5 +printf '%s\n' "$gl_cv_next_wchar_h" >&6; } fi NEXT_WCHAR_H=$gl_cv_next_wchar_h @@ -40202,7 +40426,7 @@ printf "%s\n" "$gl_cv_next_wchar_h" >&6; } ac_fn_check_decl "$LINENO" "wcsdup" "ac_cv_have_decl_wcsdup" " #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_wcsdup" = xyes then : ac_have_decl=1 @@ -40210,7 +40434,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_WCSDUP $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_WCSDUP $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_wcsdup = no; then HAVE_DECL_WCSDUP=0 @@ -40219,7 +40443,7 @@ printf "%s\n" "@%:@define HAVE_DECL_WCSDUP $ac_have_decl" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler option to allow warnings" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler option to allow warnings" >&5 printf %s "checking for C compiler option to allow warnings... " >&6; } if test ${gl_cv_cc_wallow+y} then : @@ -40231,13 +40455,13 @@ else case e in @%:@( { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null { ac_try='${CC-cc} $CFLAGS $CPPFLAGS -Wno-error -c conftest.c 2>conftest2.err' { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 (eval $ac_try) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; } >/dev/null if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then gl_cv_cc_wallow='-Wno-error' @@ -40248,8 +40472,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_wallow" >&5 -printf "%s\n" "$gl_cv_cc_wallow" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_wallow" >&5 +printf '%s\n' "$gl_cv_cc_wallow" >&6; } case "$gl_cv_cc_wallow" in none) GL_CFLAG_ALLOW_WARNINGS='' ;; *) GL_CFLAG_ALLOW_WARNINGS="$gl_cv_cc_wallow" ;; @@ -40294,7 +40518,7 @@ EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$gl_command\""; } >&5 (eval $gl_command) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then gl_options=`grep -v '#' conftest.out` for word in $gl_options; do @@ -40333,7 +40557,7 @@ fi gl_source_base='gnulib-lib' gl_source_base_prefix= - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for alignas and alignof" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for alignas and alignof" >&5 printf %s "checking for alignas and alignof... " >&6; } if test ${gl_cv_header_working_stdalign_h+y} then : @@ -40405,13 +40629,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_stdalign_h" >&5 -printf "%s\n" "$gl_cv_header_working_stdalign_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_header_working_stdalign_h" >&5 +printf '%s\n' "$gl_cv_header_working_stdalign_h" >&6; } case $gl_cv_header_working_stdalign_h in @%:@( yes*keyword*) : -printf "%s\n" "@%:@define HAVE_C_ALIGNASOF 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_C_ALIGNASOF 1" >>confdefs.h ;; @%:@( *) : ;; @@ -40427,7 +40651,7 @@ esac # Define an additional variable used in the Makefile substitution. if test $ac_cv_working_alloca_h = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for alloca as a compiler built-in" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for alloca as a compiler built-in" >&5 printf %s "checking for alloca as a compiler built-in... " >&6; } if test ${gl_cv_rpl_alloca+y} then : @@ -40455,11 +40679,11 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_rpl_alloca" >&5 -printf "%s\n" "$gl_cv_rpl_alloca" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_rpl_alloca" >&5 +printf '%s\n' "$gl_cv_rpl_alloca" >&6; } if test $gl_cv_rpl_alloca = yes; then -printf "%s\n" "@%:@define HAVE_ALLOCA 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ALLOCA 1" >>confdefs.h GL_GENERATE_ALLOCA_H=true else @@ -40510,7 +40734,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for static_assert" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for static_assert" >&5 printf %s "checking for static_assert... " >&6; } if test ${gl_cv_static_assert+y} then : @@ -40561,14 +40785,14 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext done ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_static_assert" >&5 -printf "%s\n" "$gl_cv_static_assert" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_static_assert" >&5 +printf '%s\n' "$gl_cv_static_assert" >&6; } GL_GENERATE_ASSERT_H=false case $gl_cv_static_assert in @%:@( yes*keyword*) : -printf "%s\n" "@%:@define HAVE_C_STATIC_ASSERT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_C_STATIC_ASSERT 1" >>confdefs.h ;; @%:@( no) : GL_GENERATE_ASSERT_H=true @@ -40583,7 +40807,7 @@ printf "%s\n" "@%:@define HAVE_C_STATIC_ASSERT 1" >>confdefs.h if test $gl_cv_have_include_next = yes; then gl_cv_next_assert_h='<'assert.h'>' else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking absolute name of " >&5 printf %s "checking absolute name of ... " >&6; } if test ${gl_cv_next_assert_h+y} then : @@ -40628,8 +40852,8 @@ _ACEOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_assert_h" >&5 -printf "%s\n" "$gl_cv_next_assert_h" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_next_assert_h" >&5 +printf '%s\n' "$gl_cv_next_assert_h" >&6; } fi NEXT_ASSERT_H=$gl_cv_next_assert_h @@ -40688,7 +40912,7 @@ fi ac_fn_c_check_func "$LINENO" "atexit" "ac_cv_func_atexit" if test "x$ac_cv_func_atexit" = xyes then : - printf "%s\n" "@%:@define HAVE_ATEXIT 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_ATEXIT 1" >>confdefs.h fi @@ -40715,7 +40939,7 @@ fi fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for __builtin_expect" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for __builtin_expect" >&5 printf %s "checking for __builtin_expect... " >&6; } if test ${gl_cv___builtin_expect+y} then : @@ -40761,13 +40985,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv___builtin_expect" >&5 -printf "%s\n" "$gl_cv___builtin_expect" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv___builtin_expect" >&5 +printf '%s\n' "$gl_cv___builtin_expect" >&6; } if test "$gl_cv___builtin_expect" = yes; then - printf "%s\n" "@%:@define HAVE___BUILTIN_EXPECT 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE___BUILTIN_EXPECT 1" >>confdefs.h elif test "$gl_cv___builtin_expect" = "in "; then - printf "%s\n" "@%:@define HAVE___BUILTIN_EXPECT 2" >>confdefs.h + printf '%s\n' "@%:@define HAVE___BUILTIN_EXPECT 2" >>confdefs.h fi @@ -40790,7 +41014,7 @@ printf "%s\n" "$gl_cv___builtin_expect" >&6; } -printf "%s\n" "@%:@define GNULIB_TEST_C32ISALNUM 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISALNUM 1" >>confdefs.h @@ -40812,7 +41036,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISALNUM 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISALPHA 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISALPHA 1" >>confdefs.h @@ -40834,7 +41058,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISALPHA 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISBLANK 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISBLANK 1" >>confdefs.h @@ -40856,7 +41080,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISBLANK 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISCNTRL 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISCNTRL 1" >>confdefs.h @@ -40878,7 +41102,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISCNTRL 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISDIGIT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISDIGIT 1" >>confdefs.h @@ -40900,7 +41124,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISDIGIT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISGRAPH 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISGRAPH 1" >>confdefs.h @@ -40922,7 +41146,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISGRAPH 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISLOWER 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISLOWER 1" >>confdefs.h @@ -40944,7 +41168,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISLOWER 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISPRINT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISPRINT 1" >>confdefs.h @@ -40966,7 +41190,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISPRINT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISPUNCT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISPUNCT 1" >>confdefs.h @@ -40988,7 +41212,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISPUNCT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISSPACE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISSPACE 1" >>confdefs.h @@ -41010,7 +41234,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISSPACE 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISUPPER 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISUPPER 1" >>confdefs.h @@ -41032,7 +41256,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISUPPER 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32ISXDIGIT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32ISXDIGIT 1" >>confdefs.h @@ -41054,7 +41278,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32ISXDIGIT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32TOLOWER 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32TOLOWER 1" >>confdefs.h @@ -41076,7 +41300,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32TOLOWER 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_C32WIDTH 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_C32WIDTH 1" >>confdefs.h @@ -41086,7 +41310,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_C32WIDTH 1" >>confdefs.h REPLACE_CALLOC_FOR_CALLOC_GNU="$REPLACE_CALLOC_FOR_CALLOC_POSIX" if test $REPLACE_CALLOC_FOR_CALLOC_GNU = 0; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether calloc (0, n) and calloc (n, 0) return nonnull" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether calloc (0, n) and calloc (n, 0) return nonnull" >&5 printf %s "checking whether calloc (0, n) and calloc (n, 0) return nonnull... " >&6; } if test ${ac_cv_func_calloc_0_nonnull+y} then : @@ -41096,8 +41320,8 @@ else case e in @%:@( ac_cv_func_calloc_0_nonnull=yes if test "$cross_compiling" = yes then : - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See 'config.log' for more details" "$LINENO" 5; } else case e in @%:@( @@ -41145,8 +41369,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_calloc_0_nonnull" >&5 -printf "%s\n" "$ac_cv_func_calloc_0_nonnull" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_calloc_0_nonnull" >&5 +printf '%s\n' "$ac_cv_func_calloc_0_nonnull" >&6; } case $ac_cv_func_calloc_0_nonnull in @%:@( *yes) : ;; @%:@( @@ -41183,7 +41407,7 @@ esac -printf "%s\n" "@%:@define GNULIB_TEST_CALLOC_GNU 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_CALLOC_GNU 1" >>confdefs.h @@ -41221,7 +41445,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_CALLOC_GNU 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_CALLOC_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_CALLOC_POSIX 1" >>confdefs.h @@ -41265,7 +41489,7 @@ fi -printf "%s\n" "@%:@define GNULIB_CANONICALIZE_LGPL 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_CANONICALIZE_LGPL 1" >>confdefs.h @@ -41283,7 +41507,7 @@ printf "%s\n" "@%:@define GNULIB_CANONICALIZE_LGPL 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_CANONICALIZE_FILE_NAME 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_CANONICALIZE_FILE_NAME 1" >>confdefs.h @@ -41302,14 +41526,14 @@ printf "%s\n" "@%:@define GNULIB_TEST_CANONICALIZE_FILE_NAME 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_REALPATH 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_REALPATH 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for readlinkat" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for readlinkat" >&5 printf %s "checking for readlinkat... " >&6; } if test ${gl_cv_onwards_func_readlinkat+y} then : @@ -41322,7 +41546,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "readlinkat" "ac_cv_have_decl_readlinkat" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_readlinkat" = xyes then : @@ -41362,8 +41586,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_readlinkat" >&5 -printf "%s\n" "$gl_cv_onwards_func_readlinkat" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_readlinkat" >&5 +printf '%s\n' "$gl_cv_onwards_func_readlinkat" >&6; } case "$gl_cv_onwards_func_readlinkat" in future*) ac_cv_func_readlinkat=no ;; @@ -41371,14 +41595,14 @@ printf "%s\n" "$gl_cv_onwards_func_readlinkat" >&6; } esac if test $ac_cv_func_readlinkat = yes; then -printf "%s\n" "@%:@define HAVE_READLINKAT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_READLINKAT 1" >>confdefs.h fi -printf "%s\n" "@%:@define GNULIB_TEST_CLOEXEC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_CLOEXEC 1" >>confdefs.h @@ -41411,7 +41635,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_CLOSE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_CLOSE 1" >>confdefs.h @@ -41420,7 +41644,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_CLOSE 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether // is distinct from /" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether // is distinct from /" >&5 printf %s "checking whether // is distinct from /... " >&6; } if test ${gl_cv_double_slash_root+y} then : @@ -41451,18 +41675,18 @@ else case e in @%:@( fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_double_slash_root" >&5 -printf "%s\n" "$gl_cv_double_slash_root" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_double_slash_root" >&5 +printf '%s\n' "$gl_cv_double_slash_root" >&6; } if test "$gl_cv_double_slash_root" = yes; then -printf "%s\n" "@%:@define DOUBLE_SLASH_IS_DISTINCT_ROOT 1" >>confdefs.h +printf '%s\n' "@%:@define DOUBLE_SLASH_IS_DISTINCT_ROOT 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether dup2 works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether dup2 works" >&5 printf %s "checking whether dup2 works... " >&6; } if test ${gl_cv_func_dup2_works+y} then : @@ -41570,8 +41794,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_dup2_works" >&5 -printf "%s\n" "$gl_cv_func_dup2_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_dup2_works" >&5 +printf '%s\n' "$gl_cv_func_dup2_works" >&6; } case "$gl_cv_func_dup2_works" in *yes) ;; *) @@ -41579,7 +41803,7 @@ printf "%s\n" "$gl_cv_func_dup2_works" >&6; } ac_fn_c_check_func "$LINENO" "setdtablesize" "ac_cv_func_setdtablesize" if test "x$ac_cv_func_setdtablesize" = xyes then : - printf "%s\n" "@%:@define HAVE_SETDTABLESIZE 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SETDTABLESIZE 1" >>confdefs.h fi @@ -41621,7 +41845,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_DUP2 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_DUP2 1" >>confdefs.h @@ -41641,7 +41865,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_DUP2 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_ENVIRON 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_ENVIRON 1" >>confdefs.h @@ -41733,7 +41957,7 @@ fi fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether fcntl handles F_DUPFD correctly" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether fcntl handles F_DUPFD correctly" >&5 printf %s "checking whether fcntl handles F_DUPFD correctly... " >&6; } if test ${gl_cv_func_fcntl_f_dupfd_works+y} then : @@ -41811,8 +42035,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_fcntl_f_dupfd_works" >&5 -printf "%s\n" "$gl_cv_func_fcntl_f_dupfd_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_fcntl_f_dupfd_works" >&5 +printf '%s\n' "$gl_cv_func_fcntl_f_dupfd_works" >&6; } case $gl_cv_func_fcntl_f_dupfd_works in *yes) ;; *) @@ -41825,11 +42049,11 @@ printf "%s\n" "$gl_cv_func_fcntl_f_dupfd_works" >&6; } fi -printf "%s\n" "@%:@define FCNTL_DUPFD_BUGGY 1" >>confdefs.h +printf '%s\n' "@%:@define FCNTL_DUPFD_BUGGY 1" >>confdefs.h ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether fcntl understands F_DUPFD_CLOEXEC" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether fcntl understands F_DUPFD_CLOEXEC" >&5 printf %s "checking whether fcntl understands F_DUPFD_CLOEXEC... " >&6; } if test ${gl_cv_func_fcntl_f_dupfd_cloexec+y} then : @@ -41904,8 +42128,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_fcntl_f_dupfd_cloexec" >&5 -printf "%s\n" "$gl_cv_func_fcntl_f_dupfd_cloexec" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_fcntl_f_dupfd_cloexec" >&5 +printf '%s\n' "$gl_cv_func_fcntl_f_dupfd_cloexec" >&6; } case "$gl_cv_func_fcntl_f_dupfd_cloexec" in *yes) ;; *) @@ -41951,7 +42175,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_FCNTL 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FCNTL 1" >>confdefs.h @@ -41963,7 +42187,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FCNTL 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for flexible array member" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for flexible array member" >&5 printf %s "checking for flexible array member... " >&6; } if test ${ac_cv_c_flexmember+y} then : @@ -42002,21 +42226,21 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_flexmember" >&5 -printf "%s\n" "$ac_cv_c_flexmember" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_flexmember" >&5 +printf '%s\n' "$ac_cv_c_flexmember" >&6; } if test $ac_cv_c_flexmember = yes; then -printf "%s\n" "@%:@define FLEXIBLE_ARRAY_MEMBER /**/" >>confdefs.h +printf '%s\n' "@%:@define FLEXIBLE_ARRAY_MEMBER /**/" >>confdefs.h else - printf "%s\n" "@%:@define FLEXIBLE_ARRAY_MEMBER 1" >>confdefs.h + printf '%s\n' "@%:@define FLEXIBLE_ARRAY_MEMBER 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether free is known to preserve errno" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether free is known to preserve errno" >&5 printf %s "checking whether free is known to preserve errno... " >&6; } if test ${gl_cv_func_free_preserves_errno+y} then : @@ -42051,13 +42275,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_free_preserves_errno" >&5 -printf "%s\n" "$gl_cv_func_free_preserves_errno" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_free_preserves_errno" >&5 +printf '%s\n' "$gl_cv_func_free_preserves_errno" >&6; } case $gl_cv_func_free_preserves_errno in *yes) -printf "%s\n" "@%:@define HAVE_FREE_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FREE_POSIX 1" >>confdefs.h ;; *) REPLACE_FREE=1 ;; @@ -42097,7 +42321,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_FREE_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FREE_POSIX 1" >>confdefs.h @@ -42165,13 +42389,13 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_FSTAT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FSTAT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_FWRITEERROR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_FWRITEERROR 1" >>confdefs.h @@ -42181,7 +42405,7 @@ printf "%s\n" "@%:@define GNULIB_FWRITEERROR 1" >>confdefs.h if test $ac_cv_func_getdtablesize = yes && test $ac_cv_have_decl_getdtablesize = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether getdtablesize works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether getdtablesize works" >&5 printf %s "checking whether getdtablesize works... " >&6; } if test ${gl_cv_func_getdtablesize_works+y} then : @@ -42238,8 +42462,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getdtablesize_works" >&5 -printf "%s\n" "$gl_cv_func_getdtablesize_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_getdtablesize_works" >&5 +printf '%s\n' "$gl_cv_func_getdtablesize_works" >&6; } case "$gl_cv_func_getdtablesize_works" in *yes | "no (limitation)") ;; *) REPLACE_GETDTABLESIZE=1 ;; @@ -42282,7 +42506,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_GETDTABLESIZE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_GETDTABLESIZE 1" >>confdefs.h @@ -42313,7 +42537,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_GETDTABLESIZE 1" >>confdefs.h -printf "%s\n" "@%:@define __GETOPT_PREFIX rpl_" >>confdefs.h +printf '%s\n' "@%:@define __GETOPT_PREFIX rpl_" >>confdefs.h GL_GENERATE_GETOPT_H=true GL_GENERATE_GETOPT_CDEFS_H=true @@ -42427,7 +42651,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_GETOPT_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_GETOPT_POSIX 1" >>confdefs.h @@ -42436,7 +42660,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_GETOPT_POSIX 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for getprogname" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for getprogname" >&5 printf %s "checking for getprogname... " >&6; } if test ${gl_cv_onwards_func_getprogname+y} then : @@ -42449,7 +42673,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "getprogname" "ac_cv_have_decl_getprogname" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_getprogname" = xyes then : @@ -42489,8 +42713,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_getprogname" >&5 -printf "%s\n" "$gl_cv_onwards_func_getprogname" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_getprogname" >&5 +printf '%s\n' "$gl_cv_onwards_func_getprogname" >&6; } case "$gl_cv_onwards_func_getprogname" in future*) ac_cv_func_getprogname=no ;; @@ -42498,7 +42722,7 @@ printf "%s\n" "$gl_cv_onwards_func_getprogname" >&6; } esac if test $ac_cv_func_getprogname = yes; then -printf "%s\n" "@%:@define HAVE_GETPROGNAME 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_GETPROGNAME 1" >>confdefs.h fi @@ -42510,7 +42734,7 @@ printf "%s\n" "@%:@define HAVE_GETPROGNAME 1" >>confdefs.h esac fi ac_fn_check_decl "$LINENO" "program_invocation_name" "ac_cv_have_decl_program_invocation_name" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_program_invocation_name" = xyes then : ac_have_decl=1 @@ -42518,7 +42742,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h if test $ac_have_decl = 1 then : @@ -42549,7 +42773,7 @@ fi ac_found=0 ac_fn_check_decl "$LINENO" "program_invocation_name" "ac_cv_have_decl_program_invocation_name" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_program_invocation_name" = xyes then : ac_have_decl=1 @@ -42557,14 +42781,14 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h if test $ac_have_decl = 1 then : ac_found=1 fi ac_fn_check_decl "$LINENO" "program_invocation_short_name" "ac_cv_have_decl_program_invocation_short_name" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_program_invocation_short_name" = xyes then : ac_have_decl=1 @@ -42572,14 +42796,14 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME $ac_have_decl" >>confdefs.h if test $ac_have_decl = 1 then : ac_found=1 fi ac_fn_check_decl "$LINENO" "__argv" "ac_cv_have_decl___argv" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl___argv" = xyes then : ac_have_decl=1 @@ -42587,7 +42811,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL___ARGV $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL___ARGV $ac_have_decl" >>confdefs.h if test $ac_have_decl = 1 then : ac_found=1 @@ -42598,7 +42822,7 @@ fi if test $ac_found = 0; then # On OpenBSD 5.1, using the global __progname variable appears to be # the only way to implement getprogname. - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether __progname is defined in default libraries" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether __progname is defined in default libraries" >&5 printf %s "checking whether __progname is defined in default libraries... " >&6; } if test ${gl_cv_var___progname+y} then : @@ -42629,11 +42853,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_var___progname" >&5 -printf "%s\n" "$gl_cv_var___progname" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_var___progname" >&5 +printf '%s\n' "$gl_cv_var___progname" >&6; } if test "$gl_cv_var___progname" = yes; then -printf "%s\n" "@%:@define HAVE_VAR___PROGNAME 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_VAR___PROGNAME 1" >>confdefs.h fi fi @@ -42655,7 +42879,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_GETPROGNAME 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_GETPROGNAME 1" >>confdefs.h @@ -42767,7 +42991,7 @@ rm -rf conftest* esac if test -n "$iconv_flavor"; then -printf "%s\n" "@%:@define ICONV_FLAVOR $iconv_flavor" >>confdefs.h +printf '%s\n' "@%:@define ICONV_FLAVOR $iconv_flavor" >>confdefs.h @@ -42847,7 +43071,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler generally respects inline" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler generally respects inline" >&5 printf %s "checking whether the compiler generally respects inline... " >&6; } if test ${gl_cv_c_inline_effective+y} then : @@ -42881,11 +43105,11 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_inline_effective" >&5 -printf "%s\n" "$gl_cv_c_inline_effective" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_inline_effective" >&5 +printf '%s\n' "$gl_cv_c_inline_effective" >&6; } if test $gl_cv_c_inline_effective = yes; then -printf "%s\n" "@%:@define HAVE_INLINE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_INLINE 1" >>confdefs.h fi @@ -42902,7 +43126,7 @@ printf "%s\n" "@%:@define HAVE_INLINE 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for iswblank" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for iswblank" >&5 printf %s "checking for iswblank... " >&6; } if test ${gl_cv_onwards_func_iswblank+y} then : @@ -42915,7 +43139,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "iswblank" "ac_cv_have_decl_iswblank" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_iswblank" = xyes then : @@ -42955,8 +43179,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_iswblank" >&5 -printf "%s\n" "$gl_cv_onwards_func_iswblank" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_iswblank" >&5 +printf '%s\n' "$gl_cv_onwards_func_iswblank" >&6; } case "$gl_cv_onwards_func_iswblank" in future*) ac_cv_func_iswblank=no ;; @@ -42964,7 +43188,7 @@ printf "%s\n" "$gl_cv_onwards_func_iswblank" >&6; } esac if test $ac_cv_func_iswblank = yes; then -printf "%s\n" "@%:@define HAVE_ISWBLANK 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_ISWBLANK 1" >>confdefs.h fi @@ -42973,7 +43197,7 @@ printf "%s\n" "@%:@define HAVE_ISWBLANK 1" >>confdefs.h #include #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_iswblank" = xyes then : ac_have_decl=1 @@ -42981,7 +43205,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_ISWBLANK $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_ISWBLANK $ac_have_decl" >>confdefs.h if test $ac_cv_func_iswblank = no; then HAVE_ISWBLANK=0 @@ -43031,7 +43255,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_ISWBLANK 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_ISWBLANK 1" >>confdefs.h @@ -43047,7 +43271,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_ISWBLANK 1" >>confdefs.h if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then REPLACE_ISWDIGIT="$REPLACE_ISWCNTRL" else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether iswdigit is ISO C compliant" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether iswdigit is ISO C compliant" >&5 printf %s "checking whether iswdigit is ISO C compliant... " >&6; } if test ${gl_cv_func_iswdigit_works+y} then : @@ -43158,8 +43382,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswdigit_works" >&5 -printf "%s\n" "$gl_cv_func_iswdigit_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswdigit_works" >&5 +printf '%s\n' "$gl_cv_func_iswdigit_works" >&6; } case "$gl_cv_func_iswdigit_works" in *yes) ;; *) REPLACE_ISWDIGIT=1 ;; @@ -43195,7 +43419,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_ISWDIGIT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_ISWDIGIT 1" >>confdefs.h @@ -43206,7 +43430,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_ISWDIGIT 1" >>confdefs.h if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then REPLACE_ISWPUNCT="$REPLACE_ISWCNTRL" else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether iswpunct is consistent with ispunct" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether iswpunct is consistent with ispunct" >&5 printf %s "checking whether iswpunct is consistent with ispunct... " >&6; } if test ${gl_cv_func_iswpunct_works+y} then : @@ -43253,8 +43477,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswpunct_works" >&5 -printf "%s\n" "$gl_cv_func_iswpunct_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswpunct_works" >&5 +printf '%s\n' "$gl_cv_func_iswpunct_works" >&6; } case "$gl_cv_func_iswpunct_works" in *yes) ;; *) REPLACE_ISWPUNCT=1 ;; @@ -43290,7 +43514,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_ISWPUNCT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_ISWPUNCT 1" >>confdefs.h @@ -43305,7 +43529,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_ISWPUNCT 1" >>confdefs.h if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then REPLACE_ISWXDIGIT="$REPLACE_ISWCNTRL" else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether iswxdigit is ISO C compliant" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether iswxdigit is ISO C compliant" >&5 printf %s "checking whether iswxdigit is ISO C compliant... " >&6; } if test ${gl_cv_func_iswxdigit_works+y} then : @@ -43407,8 +43631,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswxdigit_works" >&5 -printf "%s\n" "$gl_cv_func_iswxdigit_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_iswxdigit_works" >&5 +printf '%s\n' "$gl_cv_func_iswxdigit_works" >&6; } case "$gl_cv_func_iswxdigit_works" in *yes) ;; *) REPLACE_ISWXDIGIT=1 ;; @@ -43444,12 +43668,12 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_ISWXDIGIT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_ISWXDIGIT 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use Java" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use Java" >&5 printf %s "checking whether to use Java... " >&6; } @%:@ Check whether --enable-java was given. if test ${enable_java+y} @@ -43460,8 +43684,8 @@ else case e in @%:@( esac fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHOICE" >&5 -printf "%s\n" "$JAVA_CHOICE" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHOICE" >&5 +printf '%s\n' "$JAVA_CHOICE" >&6; } # You need to invoke gt_JAVACOMP yourself, possibly with arguments. @@ -43476,7 +43700,7 @@ printf "%s\n" "$JAVA_CHOICE" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports the __inline keyword" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports the __inline keyword" >&5 printf %s "checking whether the compiler supports the __inline keyword... " >&6; } if test ${gl_cv_c___inline+y} then : @@ -43504,11 +43728,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c___inline" >&5 -printf "%s\n" "$gl_cv_c___inline" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c___inline" >&5 +printf '%s\n' "$gl_cv_c___inline" >&6; } if test $gl_cv_c___inline = yes; then -printf "%s\n" "@%:@define HAVE___INLINE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE___INLINE 1" >>confdefs.h fi @@ -43568,7 +43792,7 @@ fi if test $HAVE_LOCALE_T = 1; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for newlocale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for newlocale" >&5 printf %s "checking for newlocale... " >&6; } if test ${gl_cv_onwards_func_newlocale+y} then : @@ -43581,7 +43805,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "newlocale" "ac_cv_have_decl_newlocale" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_newlocale" = xyes then : @@ -43621,8 +43845,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_newlocale" >&5 -printf "%s\n" "$gl_cv_onwards_func_newlocale" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_newlocale" >&5 +printf '%s\n' "$gl_cv_onwards_func_newlocale" >&6; } case "$gl_cv_onwards_func_newlocale" in future*) ac_cv_func_newlocale=no ;; @@ -43630,14 +43854,14 @@ printf "%s\n" "$gl_cv_onwards_func_newlocale" >&6; } esac if test $ac_cv_func_newlocale = yes; then -printf "%s\n" "@%:@define HAVE_NEWLOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_NEWLOCALE 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for duplocale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for duplocale" >&5 printf %s "checking for duplocale... " >&6; } if test ${gl_cv_onwards_func_duplocale+y} then : @@ -43650,7 +43874,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "duplocale" "ac_cv_have_decl_duplocale" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_duplocale" = xyes then : @@ -43690,8 +43914,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_duplocale" >&5 -printf "%s\n" "$gl_cv_onwards_func_duplocale" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_duplocale" >&5 +printf '%s\n' "$gl_cv_onwards_func_duplocale" >&6; } case "$gl_cv_onwards_func_duplocale" in future*) ac_cv_func_duplocale=no ;; @@ -43699,14 +43923,14 @@ printf "%s\n" "$gl_cv_onwards_func_duplocale" >&6; } esac if test $ac_cv_func_duplocale = yes; then -printf "%s\n" "@%:@define HAVE_DUPLOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DUPLOCALE 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freelocale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for freelocale" >&5 printf %s "checking for freelocale... " >&6; } if test ${gl_cv_onwards_func_freelocale+y} then : @@ -43719,7 +43943,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "freelocale" "ac_cv_have_decl_freelocale" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_freelocale" = xyes then : @@ -43759,8 +43983,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_freelocale" >&5 -printf "%s\n" "$gl_cv_onwards_func_freelocale" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_freelocale" >&5 +printf '%s\n' "$gl_cv_onwards_func_freelocale" >&6; } case "$gl_cv_onwards_func_freelocale" in future*) ac_cv_func_freelocale=no ;; @@ -43768,7 +43992,7 @@ printf "%s\n" "$gl_cv_onwards_func_freelocale" >&6; } esac if test $ac_cv_func_freelocale = yes; then -printf "%s\n" "@%:@define HAVE_FREELOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FREELOCALE 1" >>confdefs.h fi @@ -43823,7 +44047,7 @@ printf "%s\n" "@%:@define HAVE_FREELOCALE 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_LOCALENAME_UNSAFE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_LOCALENAME_UNSAFE 1" >>confdefs.h @@ -43859,14 +44083,14 @@ if test "x$ac_cv_type_pthread_rwlock_t" = xyes then : has_rwlock=true -printf "%s\n" "@%:@define HAVE_PTHREAD_RWLOCK 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_RWLOCK 1" >>confdefs.h fi if $has_rwlock; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthread_rwlock_rdlock prefers a writer to a reader" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether pthread_rwlock_rdlock prefers a writer to a reader" >&5 printf %s "checking whether pthread_rwlock_rdlock prefers a writer to a reader... " >&6; } if test ${gl_cv_pthread_rwlock_rdlock_prefer_writer+y} then : @@ -44027,12 +44251,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_pthread_rwlock_rdlock_prefer_writer" >&5 -printf "%s\n" "$gl_cv_pthread_rwlock_rdlock_prefer_writer" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_pthread_rwlock_rdlock_prefer_writer" >&5 +printf '%s\n' "$gl_cv_pthread_rwlock_rdlock_prefer_writer" >&6; } case "$gl_cv_pthread_rwlock_rdlock_prefer_writer" in *yes) -printf "%s\n" "@%:@define HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER 1" >>confdefs.h ;; esac @@ -44064,7 +44288,7 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : -printf "%s\n" "@%:@define HAVE_PTHREAD_MUTEX_RECURSIVE 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_PTHREAD_MUTEX_RECURSIVE 1" >>confdefs.h fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext @@ -44073,7 +44297,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext -printf "%s\n" "@%:@define GNULIB_LOCK 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_LOCK 1" >>confdefs.h @@ -44082,7 +44306,7 @@ printf "%s\n" "@%:@define GNULIB_LOCK 1" >>confdefs.h REPLACE_MALLOC_FOR_MALLOC_GNU="$REPLACE_MALLOC_FOR_MALLOC_POSIX" if test $REPLACE_MALLOC_FOR_MALLOC_GNU = 0; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether malloc (0) returns nonnull" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether malloc (0) returns nonnull" >&5 printf %s "checking whether malloc (0) returns nonnull... " >&6; } if test ${ac_cv_func_malloc_0_nonnull+y} then : @@ -44133,8 +44357,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5 -printf "%s\n" "$ac_cv_func_malloc_0_nonnull" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5 +printf '%s\n' "$ac_cv_func_malloc_0_nonnull" >&6; } case $ac_cv_func_malloc_0_nonnull in @%:@( *yes) : ;; @%:@( @@ -44171,7 +44395,7 @@ esac -printf "%s\n" "@%:@define GNULIB_TEST_MALLOC_GNU 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MALLOC_GNU 1" >>confdefs.h @@ -44203,7 +44427,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MALLOC_GNU 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_MALLOC_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MALLOC_POSIX 1" >>confdefs.h @@ -44231,7 +44455,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MALLOC_POSIX 1" >>confdefs.h else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtoc32 works on empty input" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtoc32 works on empty input" >&5 printf %s "checking whether mbrtoc32 works on empty input... " >&6; } if test ${gl_cv_func_mbrtoc32_empty_input+y} then : @@ -44281,11 +44505,11 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_empty_input" >&5 -printf "%s\n" "$gl_cv_func_mbrtoc32_empty_input" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_empty_input" >&5 +printf '%s\n' "$gl_cv_func_mbrtoc32_empty_input" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C locale is free of encoding errors" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C locale is free of encoding errors" >&5 printf %s "checking whether the C locale is free of encoding errors... " >&6; } if test ${gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ+y} then : @@ -44347,13 +44571,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" >&5 -printf "%s\n" "$gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" >&5 +printf '%s\n' "$gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" >&6; } case "$gl_cv_func_mbrtoc32_empty_input" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOC32_EMPTY_INPUT_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOC32_EMPTY_INPUT_BUG 1" >>confdefs.h REPLACE_MBRTOC32=1 ;; @@ -44361,7 +44585,7 @@ printf "%s\n" "@%:@define MBRTOC32_EMPTY_INPUT_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ 1" >>confdefs.h REPLACE_MBRTOC32=1 ;; @@ -44415,7 +44639,7 @@ fi CFLAG_VISIBILITY= HAVE_VISIBILITY=0 if test -n "$GCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 printf %s "checking whether the -Werror option is usable... " >&6; } if test ${gl_cv_cc_vis_werror+y} then : @@ -44446,9 +44670,9 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 -printf "%s\n" "$gl_cv_cc_vis_werror" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 +printf '%s\n' "$gl_cv_cc_vis_werror" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 printf %s "checking for simple visibility declarations... " >&6; } if test ${gl_cv_cc_visibility+y} then : @@ -44487,8 +44711,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 -printf "%s\n" "$gl_cv_cc_visibility" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 +printf '%s\n' "$gl_cv_cc_visibility" >&6; } if test $gl_cv_cc_visibility = yes; then CFLAG_VISIBILITY="-fvisibility=hidden" HAVE_VISIBILITY=1 @@ -44497,7 +44721,7 @@ printf "%s\n" "$gl_cv_cc_visibility" >&6; } -printf "%s\n" "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h +printf '%s\n' "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h @@ -44522,7 +44746,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_MBRTOC32 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBRTOC32 1" >>confdefs.h @@ -44540,7 +44764,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MBRTOC32 1" >>confdefs.h ac_fn_check_decl "$LINENO" "mbrtowc" "ac_cv_have_decl_mbrtowc" " #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_mbrtowc" = xyes then : ac_have_decl=1 @@ -44548,7 +44772,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_MBRTOWC $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_MBRTOWC $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_mbrtowc = yes; then REPLACE_MBRTOWC=1 @@ -44560,7 +44784,7 @@ printf "%s\n" "@%:@define HAVE_DECL_MBRTOWC $ac_have_decl" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles a NULL pwc argument" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles a NULL pwc argument" >&5 printf %s "checking whether mbrtowc handles a NULL pwc argument... " >&6; } if test ${gl_cv_func_mbrtowc_null_arg1+y} then : @@ -44630,13 +44854,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_null_arg1" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_null_arg1" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_null_arg1" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_null_arg1" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles a NULL string argument" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc handles a NULL string argument" >&5 printf %s "checking whether mbrtowc handles a NULL string argument... " >&6; } if test ${gl_cv_func_mbrtowc_null_arg2+y} then : @@ -44694,15 +44918,15 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_null_arg2" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_null_arg2" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_null_arg2" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_null_arg2" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc has a correct return value" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc has a correct return value" >&5 printf %s "checking whether mbrtowc has a correct return value... " >&6; } if test ${gl_cv_func_mbrtowc_retval+y} then : @@ -44835,13 +45059,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_retval" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_retval" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_retval" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_retval" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc returns 0 when parsing a NUL character" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc returns 0 when parsing a NUL character" >&5 printf %s "checking whether mbrtowc returns 0 when parsing a NUL character... " >&6; } if test ${gl_cv_func_mbrtowc_nul_retval+y} then : @@ -44896,12 +45120,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_nul_retval" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_nul_retval" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_nul_retval" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_nul_retval" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc stores incomplete characters" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc stores incomplete characters" >&5 printf %s "checking whether mbrtowc stores incomplete characters... " >&6; } if test ${gl_cv_func_mbrtowc_stores_incomplete+y} then : @@ -45030,12 +45254,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_stores_incomplete" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_stores_incomplete" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_stores_incomplete" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_stores_incomplete" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc works on empty input" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc works on empty input" >&5 printf %s "checking whether mbrtowc works on empty input... " >&6; } if test ${gl_cv_func_mbrtowc_empty_input+y} then : @@ -45081,11 +45305,11 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_empty_input" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_empty_input" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_empty_input" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_empty_input" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C locale is free of encoding errors" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C locale is free of encoding errors" >&5 printf %s "checking whether the C locale is free of encoding errors... " >&6; } if test ${gl_cv_func_mbrtowc_C_locale_sans_EILSEQ+y} then : @@ -45144,13 +45368,13 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" >&5 -printf "%s\n" "$gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" >&5 +printf '%s\n' "$gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" >&6; } case "$gl_cv_func_mbrtowc_null_arg1" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_NULL_ARG1_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_NULL_ARG1_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45158,7 +45382,7 @@ printf "%s\n" "@%:@define MBRTOWC_NULL_ARG1_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_null_arg2" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_NULL_ARG2_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_NULL_ARG2_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45166,7 +45390,7 @@ printf "%s\n" "@%:@define MBRTOWC_NULL_ARG2_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_retval" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_RETVAL_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_RETVAL_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45174,7 +45398,7 @@ printf "%s\n" "@%:@define MBRTOWC_RETVAL_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_nul_retval" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_NUL_RETVAL_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_NUL_RETVAL_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45182,7 +45406,7 @@ printf "%s\n" "@%:@define MBRTOWC_NUL_RETVAL_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_stores_incomplete" in *no) ;; *) -printf "%s\n" "@%:@define MBRTOWC_STORES_INCOMPLETE_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_STORES_INCOMPLETE_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45190,7 +45414,7 @@ printf "%s\n" "@%:@define MBRTOWC_STORES_INCOMPLETE_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_empty_input" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_EMPTY_INPUT_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_EMPTY_INPUT_BUG 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45198,7 +45422,7 @@ printf "%s\n" "@%:@define MBRTOWC_EMPTY_INPUT_BUG 1" >>confdefs.h case "$gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" in *yes) ;; *) -printf "%s\n" "@%:@define MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ 1" >>confdefs.h +printf '%s\n' "@%:@define MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ 1" >>confdefs.h REPLACE_MBRTOWC=1 ;; @@ -45213,7 +45437,7 @@ printf "%s\n" "@%:@define MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ 1" >>confdefs.h *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 printf %s "checking whether imported symbols can be declared weak... " >&6; } if test ${gl_cv_have_weak+y} then : @@ -45317,12 +45541,12 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 -printf "%s\n" "$gl_cv_have_weak" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 +printf '%s\n' "$gl_cv_have_weak" >&6; } case "$gl_cv_have_weak" in *yes) -printf "%s\n" "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h ;; esac @@ -45383,7 +45607,7 @@ fi CFLAG_VISIBILITY= HAVE_VISIBILITY=0 if test -n "$GCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 printf %s "checking whether the -Werror option is usable... " >&6; } if test ${gl_cv_cc_vis_werror+y} then : @@ -45414,9 +45638,9 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 -printf "%s\n" "$gl_cv_cc_vis_werror" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 +printf '%s\n' "$gl_cv_cc_vis_werror" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 printf %s "checking for simple visibility declarations... " >&6; } if test ${gl_cv_cc_visibility+y} then : @@ -45455,8 +45679,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 -printf "%s\n" "$gl_cv_cc_visibility" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 +printf '%s\n' "$gl_cv_cc_visibility" >&6; } if test $gl_cv_cc_visibility = yes; then CFLAG_VISIBILITY="-fvisibility=hidden" HAVE_VISIBILITY=1 @@ -45465,7 +45689,7 @@ printf "%s\n" "$gl_cv_cc_visibility" >&6; } -printf "%s\n" "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h +printf '%s\n' "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h @@ -45496,7 +45720,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_MBRTOWC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBRTOWC 1" >>confdefs.h @@ -45513,7 +45737,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MBRTOWC 1" >>confdefs.h ac_fn_check_decl "$LINENO" "mbsinit" "ac_cv_have_decl_mbsinit" " #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_mbsinit" = xyes then : ac_have_decl=1 @@ -45521,7 +45745,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_MBSINIT $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_MBSINIT $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_mbsinit = yes; then REPLACE_MBSINIT=1 @@ -45577,7 +45801,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_MBSINIT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBSINIT 1" >>confdefs.h @@ -45610,7 +45834,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MBSINIT 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_MBSLEN 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBSLEN 1" >>confdefs.h @@ -45634,7 +45858,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MBSLEN 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_MBSSTR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBSSTR 1" >>confdefs.h @@ -45661,7 +45885,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MBSSTR 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_MBSZERO 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MBSZERO 1" >>confdefs.h @@ -45694,7 +45918,7 @@ fi ac_fn_c_check_header_compile "$LINENO" "bp-sym.h" "ac_cv_header_bp_sym_h" "$ac_includes_default" if test "x$ac_cv_header_bp_sym_h" = xyes then : - printf "%s\n" "@%:@define HAVE_BP_SYM_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_BP_SYM_H 1" >>confdefs.h fi @@ -45721,7 +45945,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_MEMCHR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MEMCHR 1" >>confdefs.h @@ -45729,7 +45953,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_MEMCHR 1" >>confdefs.h ac_fn_c_check_func "$LINENO" "memmove" "ac_cv_func_memmove" if test "x$ac_cv_func_memmove" = xyes then : - printf "%s\n" "@%:@define HAVE_MEMMOVE 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_MEMMOVE 1" >>confdefs.h fi @@ -45763,7 +45987,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for mempcpy" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for mempcpy" >&5 printf %s "checking for mempcpy... " >&6; } if test ${gl_cv_onwards_func_mempcpy+y} then : @@ -45776,7 +46000,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "mempcpy" "ac_cv_have_decl_mempcpy" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_mempcpy" = xyes then : @@ -45816,8 +46040,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_mempcpy" >&5 -printf "%s\n" "$gl_cv_onwards_func_mempcpy" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_mempcpy" >&5 +printf '%s\n' "$gl_cv_onwards_func_mempcpy" >&6; } case "$gl_cv_onwards_func_mempcpy" in future*) ac_cv_func_mempcpy=no ;; @@ -45825,7 +46049,7 @@ printf "%s\n" "$gl_cv_onwards_func_mempcpy" >&6; } esac if test $ac_cv_func_mempcpy = yes; then -printf "%s\n" "@%:@define HAVE_MEMPCPY 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MEMPCPY 1" >>confdefs.h fi @@ -45878,7 +46102,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_MEMPCPY 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_MEMPCPY 1" >>confdefs.h @@ -45917,7 +46141,7 @@ fi -printf "%s\n" "@%:@define GNULIB_MSVC_NOTHROW 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_MSVC_NOTHROW 1" >>confdefs.h @@ -45935,7 +46159,7 @@ printf "%s\n" "@%:@define GNULIB_MSVC_NOTHROW 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether open recognizes a trailing slash" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether open recognizes a trailing slash" >&5 printf %s "checking whether open recognizes a trailing slash... " >&6; } if test ${gl_cv_func_open_slash+y} then : @@ -45996,12 +46220,12 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_open_slash" >&5 -printf "%s\n" "$gl_cv_func_open_slash" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_open_slash" >&5 +printf '%s\n' "$gl_cv_func_open_slash" >&6; } case "$gl_cv_func_open_slash" in *no) -printf "%s\n" "@%:@define OPEN_TRAILING_SLASH_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define OPEN_TRAILING_SLASH_BUG 1" >>confdefs.h ;; esac @@ -46053,7 +46277,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_OPEN 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_OPEN 1" >>confdefs.h @@ -46061,7 +46285,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_OPEN 1" >>confdefs.h ac_fn_check_decl "$LINENO" "program_invocation_name" "ac_cv_have_decl_program_invocation_name" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_program_invocation_name" = xyes then : ac_have_decl=1 @@ -46069,10 +46293,10 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PROGRAM_INVOCATION_NAME $ac_have_decl" >>confdefs.h ac_fn_check_decl "$LINENO" "program_invocation_short_name" "ac_cv_have_decl_program_invocation_short_name" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_program_invocation_short_name" = xyes then : ac_have_decl=1 @@ -46080,7 +46304,7 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME $ac_have_decl" >>confdefs.h @@ -46096,7 +46320,7 @@ printf "%s\n" "@%:@define HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME $ac_have_decl" ac_fn_c_check_func "$LINENO" "raise" "ac_cv_func_raise" if test "x$ac_cv_func_raise" = xyes then : - printf "%s\n" "@%:@define HAVE_RAISE 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_RAISE 1" >>confdefs.h fi @@ -46170,7 +46394,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_RAISE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_RAISE 1" >>confdefs.h @@ -46181,7 +46405,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_RAISE 1" >>confdefs.h ac_fn_c_check_func "$LINENO" "rawmemchr" "ac_cv_func_rawmemchr" if test "x$ac_cv_func_rawmemchr" = xyes then : - printf "%s\n" "@%:@define HAVE_RAWMEMCHR 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_RAWMEMCHR 1" >>confdefs.h fi @@ -46228,7 +46452,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_RAWMEMCHR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_RAWMEMCHR 1" >>confdefs.h @@ -46238,7 +46462,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_RAWMEMCHR 1" >>confdefs.h if test $ac_cv_func_readlink = no; then HAVE_READLINK=0 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether readlink signature is correct" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether readlink signature is correct" >&5 printf %s "checking whether readlink signature is correct... " >&6; } if test ${gl_cv_decl_readlink_works+y} then : @@ -46267,9 +46491,9 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_decl_readlink_works" >&5 -printf "%s\n" "$gl_cv_decl_readlink_works" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether readlink handles trailing slash correctly" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_decl_readlink_works" >&5 +printf '%s\n' "$gl_cv_decl_readlink_works" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether readlink handles trailing slash correctly" >&5 printf %s "checking whether readlink handles trailing slash correctly... " >&6; } if test ${gl_cv_func_readlink_trailing_slash+y} then : @@ -46324,8 +46548,8 @@ fi rm -f conftest.link conftest.lnk2 ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_readlink_trailing_slash" >&5 -printf "%s\n" "$gl_cv_func_readlink_trailing_slash" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_readlink_trailing_slash" >&5 +printf '%s\n' "$gl_cv_func_readlink_trailing_slash" >&6; } case "$gl_cv_func_readlink_trailing_slash" in *yes) if test "$gl_cv_decl_readlink_works" != yes; then @@ -46334,13 +46558,13 @@ printf "%s\n" "$gl_cv_func_readlink_trailing_slash" >&6; } ;; *) -printf "%s\n" "@%:@define READLINK_TRAILING_SLASH_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define READLINK_TRAILING_SLASH_BUG 1" >>confdefs.h REPLACE_READLINK=1 ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether readlink truncates results correctly" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether readlink truncates results correctly" >&5 printf %s "checking whether readlink truncates results correctly... " >&6; } if test ${gl_cv_func_readlink_truncate+y} then : @@ -46394,8 +46618,8 @@ fi rm -f conftest.link conftest.lnk2 ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_readlink_truncate" >&5 -printf "%s\n" "$gl_cv_func_readlink_truncate" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_readlink_truncate" >&5 +printf '%s\n' "$gl_cv_func_readlink_truncate" >&6; } case $gl_cv_func_readlink_truncate in *yes) if test "$gl_cv_decl_readlink_works" != yes; then @@ -46404,7 +46628,7 @@ printf "%s\n" "$gl_cv_func_readlink_truncate" >&6; } ;; *) -printf "%s\n" "@%:@define READLINK_TRUNCATE_BUG 1" >>confdefs.h +printf '%s\n' "@%:@define READLINK_TRUNCATE_BUG 1" >>confdefs.h REPLACE_READLINK=1 ;; @@ -46447,7 +46671,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_READLINK 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_READLINK 1" >>confdefs.h @@ -46456,7 +46680,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_READLINK 1" >>confdefs.h if test $REPLACE_REALLOC_FOR_REALLOC_GNU = 0; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether realloc (0, 0) returns nonnull" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether realloc (0, 0) returns nonnull" >&5 printf %s "checking whether realloc (0, 0) returns nonnull... " >&6; } if test ${ac_cv_func_realloc_0_nonnull+y} then : @@ -46507,8 +46731,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5 -printf "%s\n" "$ac_cv_func_realloc_0_nonnull" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5 +printf '%s\n' "$ac_cv_func_realloc_0_nonnull" >&6; } case $ac_cv_func_realloc_0_nonnull in @%:@( *yes) : ;; @%:@( @@ -46545,7 +46769,7 @@ esac -printf "%s\n" "@%:@define GNULIB_TEST_REALLOC_GNU 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_REALLOC_GNU 1" >>confdefs.h @@ -46583,7 +46807,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_REALLOC_GNU 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_REALLOC_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_REALLOC_POSIX 1" >>confdefs.h @@ -46594,7 +46818,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_REALLOC_POSIX 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for reallocarray" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for reallocarray" >&5 printf %s "checking for reallocarray... " >&6; } if test ${gl_cv_onwards_func_reallocarray+y} then : @@ -46607,7 +46831,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "reallocarray" "ac_cv_have_decl_reallocarray" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_reallocarray" = xyes then : @@ -46647,8 +46871,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_reallocarray" >&5 -printf "%s\n" "$gl_cv_onwards_func_reallocarray" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_reallocarray" >&5 +printf '%s\n' "$gl_cv_onwards_func_reallocarray" >&6; } case "$gl_cv_onwards_func_reallocarray" in future*) ac_cv_func_reallocarray=no ;; @@ -46656,7 +46880,7 @@ printf "%s\n" "$gl_cv_onwards_func_reallocarray" >&6; } esac if test $ac_cv_func_reallocarray = yes; then -printf "%s\n" "@%:@define HAVE_REALLOCARRAY 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_REALLOCARRAY 1" >>confdefs.h fi @@ -46691,7 +46915,7 @@ fi fi -printf "%s\n" "@%:@define GNULIB_REALLOCARRAY 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_REALLOCARRAY 1" >>confdefs.h @@ -46709,7 +46933,7 @@ printf "%s\n" "@%:@define GNULIB_REALLOCARRAY 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_REALLOCARRAY 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_REALLOCARRAY 1" >>confdefs.h @@ -46763,7 +46987,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for faccessat" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for faccessat" >&5 printf %s "checking for faccessat... " >&6; } if test ${gl_cv_onwards_func_faccessat+y} then : @@ -46776,7 +47000,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "faccessat" "ac_cv_have_decl_faccessat" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_faccessat" = xyes then : @@ -46816,8 +47040,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_faccessat" >&5 -printf "%s\n" "$gl_cv_onwards_func_faccessat" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_faccessat" >&5 +printf '%s\n' "$gl_cv_onwards_func_faccessat" >&6; } case "$gl_cv_onwards_func_faccessat" in future*) ac_cv_func_faccessat=no ;; @@ -46825,7 +47049,7 @@ printf "%s\n" "$gl_cv_onwards_func_faccessat" >&6; } esac if test $ac_cv_func_faccessat = yes; then -printf "%s\n" "@%:@define HAVE_FACCESSAT 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FACCESSAT 1" >>confdefs.h fi @@ -46837,7 +47061,7 @@ printf "%s\n" "@%:@define HAVE_FACCESSAT 1" >>confdefs.h *) ac_fn_c_check_func "$LINENO" "getcwd" "ac_cv_func_getcwd" if test "x$ac_cv_func_getcwd" = xyes then : - printf "%s\n" "@%:@define HAVE_GETCWD 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_GETCWD 1" >>confdefs.h fi ;; @@ -46853,7 +47077,7 @@ fi if test "$gl_cv_func_malloc_posix" = yes; then -printf "%s\n" "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h else REPLACE_MALLOC_FOR_MALLOC_POSIX=1 @@ -46869,7 +47093,7 @@ printf "%s\n" "@%:@define HAVE_MALLOC_POSIX 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether free is known to preserve errno" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether free is known to preserve errno" >&5 printf %s "checking whether free is known to preserve errno... " >&6; } if test ${gl_cv_func_free_preserves_errno+y} then : @@ -46904,13 +47128,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_free_preserves_errno" >&5 -printf "%s\n" "$gl_cv_func_free_preserves_errno" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_free_preserves_errno" >&5 +printf '%s\n' "$gl_cv_func_free_preserves_errno" >&6; } case $gl_cv_func_free_preserves_errno in *yes) -printf "%s\n" "@%:@define HAVE_FREE_POSIX 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_FREE_POSIX 1" >>confdefs.h ;; *) REPLACE_FREE=1 ;; @@ -46924,7 +47148,7 @@ printf "%s\n" "@%:@define HAVE_FREE_POSIX 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for mempcpy" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for mempcpy" >&5 printf %s "checking for mempcpy... " >&6; } if test ${gl_cv_onwards_func_mempcpy+y} then : @@ -46937,7 +47161,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "mempcpy" "ac_cv_have_decl_mempcpy" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_mempcpy" = xyes then : @@ -46977,8 +47201,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_mempcpy" >&5 -printf "%s\n" "$gl_cv_onwards_func_mempcpy" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_mempcpy" >&5 +printf '%s\n' "$gl_cv_onwards_func_mempcpy" >&6; } case "$gl_cv_onwards_func_mempcpy" in future*) ac_cv_func_mempcpy=no ;; @@ -46986,7 +47210,7 @@ printf "%s\n" "$gl_cv_onwards_func_mempcpy" >&6; } esac if test $ac_cv_func_mempcpy = yes; then -printf "%s\n" "@%:@define HAVE_MEMPCPY 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_MEMPCPY 1" >>confdefs.h fi @@ -47005,7 +47229,7 @@ printf "%s\n" "@%:@define HAVE_MEMPCPY 1" >>confdefs.h ac_fn_c_check_func "$LINENO" "rawmemchr" "ac_cv_func_rawmemchr" if test "x$ac_cv_func_rawmemchr" = xyes then : - printf "%s\n" "@%:@define HAVE_RAWMEMCHR 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_RAWMEMCHR 1" >>confdefs.h fi @@ -47032,13 +47256,13 @@ fi ac_fn_c_check_header_compile "$LINENO" "search.h" "ac_cv_header_search_h" "$ac_includes_default" if test "x$ac_cv_header_search_h" = xyes then : - printf "%s\n" "@%:@define HAVE_SEARCH_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SEARCH_H 1" >>confdefs.h fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for tsearch" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for tsearch" >&5 printf %s "checking for tsearch... " >&6; } if test ${gl_cv_onwards_func_tsearch+y} then : @@ -47051,7 +47275,7 @@ else case e in @%:@( linux*-android*) ac_fn_check_decl "$LINENO" "tsearch" "ac_cv_have_decl_tsearch" "#include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_tsearch" = xyes then : @@ -47091,8 +47315,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_tsearch" >&5 -printf "%s\n" "$gl_cv_onwards_func_tsearch" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_onwards_func_tsearch" >&5 +printf '%s\n' "$gl_cv_onwards_func_tsearch" >&6; } case "$gl_cv_onwards_func_tsearch" in future*) ac_cv_func_tsearch=no ;; @@ -47100,7 +47324,7 @@ printf "%s\n" "$gl_cv_onwards_func_tsearch" >&6; } esac if test $ac_cv_func_tsearch = yes; then -printf "%s\n" "@%:@define HAVE_TSEARCH 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_TSEARCH 1" >>confdefs.h fi @@ -47121,7 +47345,7 @@ printf "%s\n" "@%:@define HAVE_TSEARCH 1" >>confdefs.h esac ;; *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether setlocale supports the C locale" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether setlocale supports the C locale" >&5 printf %s "checking whether setlocale supports the C locale... " >&6; } if test ${gl_cv_func_setlocale_works+y} then : @@ -47161,8 +47385,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_works" >&5 -printf "%s\n" "$gl_cv_func_setlocale_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_works" >&5 +printf '%s\n' "$gl_cv_func_setlocale_works" >&6; } case "$gl_cv_func_setlocale_works" in *yes) ;; *) NEED_SETLOCALE_IMPROVED=1 ;; @@ -47170,7 +47394,7 @@ printf "%s\n" "$gl_cv_func_setlocale_works" >&6; } ;; esac -printf "%s\n" "@%:@define NEED_SETLOCALE_IMPROVED $NEED_SETLOCALE_IMPROVED" >>confdefs.h +printf '%s\n' "@%:@define NEED_SETLOCALE_IMPROVED $NEED_SETLOCALE_IMPROVED" >>confdefs.h NEED_SETLOCALE_MTSAFE=0 @@ -47178,7 +47402,7 @@ printf "%s\n" "@%:@define NEED_SETLOCALE_IMPROVED $NEED_SETLOCALE_IMPROVED" >>co NEED_SETLOCALE_MTSAFE=1 fi -printf "%s\n" "@%:@define NEED_SETLOCALE_MTSAFE $NEED_SETLOCALE_MTSAFE" >>confdefs.h +printf '%s\n' "@%:@define NEED_SETLOCALE_MTSAFE $NEED_SETLOCALE_MTSAFE" >>confdefs.h if test $NEED_SETLOCALE_IMPROVED = 1 || test $NEED_SETLOCALE_MTSAFE = 1; then @@ -47230,7 +47454,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_SETLOCALE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_SETLOCALE 1" >>confdefs.h @@ -47239,7 +47463,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_SETLOCALE 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether setlocale (LC_ALL, NULL) is multithread-safe" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether setlocale (LC_ALL, NULL) is multithread-safe" >&5 printf %s "checking whether setlocale (LC_ALL, NULL) is multithread-safe... " >&6; } if test ${gl_cv_func_setlocale_null_all_mtsafe+y} then : @@ -47283,8 +47507,8 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_all_mtsafe" >&5 -printf "%s\n" "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_all_mtsafe" >&5 +printf '%s\n' "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } case "$host_os" in mingw* | windows*) ;; *) @@ -47298,10 +47522,10 @@ printf "%s\n" "$gl_cv_func_setlocale_null_all_mtsafe" >&6; } *) SETLOCALE_NULL_ALL_MTSAFE=0 ;; esac -printf "%s\n" "@%:@define SETLOCALE_NULL_ALL_MTSAFE $SETLOCALE_NULL_ALL_MTSAFE" >>confdefs.h +printf '%s\n' "@%:@define SETLOCALE_NULL_ALL_MTSAFE $SETLOCALE_NULL_ALL_MTSAFE" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether setlocale (category, NULL) is multithread-safe" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether setlocale (category, NULL) is multithread-safe" >&5 printf %s "checking whether setlocale (category, NULL) is multithread-safe... " >&6; } if test ${gl_cv_func_setlocale_null_one_mtsafe+y} then : @@ -47321,8 +47545,8 @@ else case e in @%:@( ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_one_mtsafe" >&5 -printf "%s\n" "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_setlocale_null_one_mtsafe" >&5 +printf '%s\n' "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } case "$host_os" in mingw* | windows*) ;; *) @@ -47336,7 +47560,7 @@ printf "%s\n" "$gl_cv_func_setlocale_null_one_mtsafe" >&6; } *) SETLOCALE_NULL_ONE_MTSAFE=0 ;; esac -printf "%s\n" "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" >>confdefs.h +printf '%s\n' "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" >>confdefs.h if test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0; then @@ -47347,7 +47571,7 @@ printf "%s\n" "@%:@define SETLOCALE_NULL_ONE_MTSAFE $SETLOCALE_NULL_ONE_MTSAFE" *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether imported symbols can be declared weak" >&5 printf %s "checking whether imported symbols can be declared weak... " >&6; } if test ${gl_cv_have_weak+y} then : @@ -47451,12 +47675,12 @@ EOF ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 -printf "%s\n" "$gl_cv_have_weak" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_have_weak" >&5 +printf '%s\n' "$gl_cv_have_weak" >&6; } case "$gl_cv_have_weak" in *yes) -printf "%s\n" "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_WEAK_SYMBOLS 1" >>confdefs.h ;; esac @@ -47496,7 +47720,7 @@ fi CFLAG_VISIBILITY= HAVE_VISIBILITY=0 if test -n "$GCC"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5 printf %s "checking whether the -Werror option is usable... " >&6; } if test ${gl_cv_cc_vis_werror+y} then : @@ -47527,9 +47751,9 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 -printf "%s\n" "$gl_cv_cc_vis_werror" >&6; } - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5 +printf '%s\n' "$gl_cv_cc_vis_werror" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5 printf %s "checking for simple visibility declarations... " >&6; } if test ${gl_cv_cc_visibility+y} then : @@ -47568,8 +47792,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 -printf "%s\n" "$gl_cv_cc_visibility" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5 +printf '%s\n' "$gl_cv_cc_visibility" >&6; } if test $gl_cv_cc_visibility = yes; then CFLAG_VISIBILITY="-fvisibility=hidden" HAVE_VISIBILITY=1 @@ -47578,7 +47802,7 @@ printf "%s\n" "$gl_cv_cc_visibility" >&6; } -printf "%s\n" "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h +printf '%s\n' "@%:@define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h @@ -47599,7 +47823,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_SETLOCALE_NULL 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_SETLOCALE_NULL 1" >>confdefs.h @@ -47615,7 +47839,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_SETLOCALE_NULL 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_SIGPIPE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_SIGPIPE 1" >>confdefs.h @@ -47693,12 +47917,12 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_SIGPROCMASK 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_SIGPROCMASK 1" >>confdefs.h - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ssize_t" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ssize_t" >&5 printf %s "checking for ssize_t... " >&6; } if test ${gl_cv_ssize_t+y} then : @@ -47726,10 +47950,10 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_ssize_t" >&5 -printf "%s\n" "$gl_cv_ssize_t" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_ssize_t" >&5 +printf '%s\n' "$gl_cv_ssize_t" >&6; } if test $gl_cv_ssize_t = no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether size_t is wider than 'long'" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether size_t is wider than 'long'" >&5 printf %s "checking whether size_t is wider than 'long'... " >&6; } if test ${gl_cv_size_t_large+y} then : @@ -47758,15 +47982,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_size_t_large" >&5 -printf "%s\n" "$gl_cv_size_t_large" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_size_t_large" >&5 +printf '%s\n' "$gl_cv_size_t_large" >&6; } if test $gl_cv_size_t_large = yes; then gl_def_ssize_t='long long' else gl_def_ssize_t='long' fi -printf "%s\n" "@%:@define ssize_t $gl_def_ssize_t" >>confdefs.h +printf '%s\n' "@%:@define ssize_t $gl_def_ssize_t" >>confdefs.h fi @@ -47779,7 +48003,7 @@ printf "%s\n" "@%:@define ssize_t $gl_def_ssize_t" >>confdefs.h REPLACE_STAT=1 ;; *) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stat handles trailing slashes on files" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stat handles trailing slashes on files" >&5 printf %s "checking whether stat handles trailing slashes on files... " >&6; } if test ${gl_cv_func_stat_file_slash+y} then : @@ -47840,13 +48064,13 @@ fi rm -f conftest.tmp conftest.lnk ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_stat_file_slash" >&5 -printf "%s\n" "$gl_cv_func_stat_file_slash" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_stat_file_slash" >&5 +printf '%s\n' "$gl_cv_func_stat_file_slash" >&6; } case $gl_cv_func_stat_file_slash in *no) REPLACE_STAT=1 -printf "%s\n" "@%:@define REPLACE_FUNC_STAT_FILE 1" >>confdefs.h +printf '%s\n' "@%:@define REPLACE_FUNC_STAT_FILE 1" >>confdefs.h ;; esac case $host_os in @@ -47908,7 +48132,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_STAT 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_STAT 1" >>confdefs.h @@ -47922,9 +48146,9 @@ printf "%s\n" "@%:@define GNULIB_TEST_STAT 1" >>confdefs.h if test "x$ac_cv_member_struct_stat_st_atim_tv_nsec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1" >>confdefs.h -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether struct stat.st_atim is of type struct timespec" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether struct stat.st_atim is of type struct timespec" >&5 printf %s "checking whether struct stat.st_atim is of type struct timespec... " >&6; } if test ${ac_cv_typeof_struct_stat_st_atim_is_struct_timespec+y} then : @@ -47962,11 +48186,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_typeof_struct_stat_st_atim_is_struct_timespec" >&5 -printf "%s\n" "$ac_cv_typeof_struct_stat_st_atim_is_struct_timespec" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_typeof_struct_stat_st_atim_is_struct_timespec" >&5 +printf '%s\n' "$ac_cv_typeof_struct_stat_st_atim_is_struct_timespec" >&6; } if test $ac_cv_typeof_struct_stat_st_atim_is_struct_timespec = yes; then -printf "%s\n" "@%:@define TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC 1" >>confdefs.h +printf '%s\n' "@%:@define TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC 1" >>confdefs.h fi else case e in @%:@( @@ -47976,7 +48200,7 @@ else case e in @%:@( if test "x$ac_cv_member_struct_stat_st_atimespec_tv_nsec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC 1" >>confdefs.h else case e in @%:@( @@ -47986,7 +48210,7 @@ else case e in @%:@( if test "x$ac_cv_member_struct_stat_st_atimensec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_ATIMENSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_ATIMENSEC 1" >>confdefs.h else case e in @%:@( @@ -47996,7 +48220,7 @@ else case e in @%:@( if test "x$ac_cv_member_struct_stat_st_atim_st__tim_tv_nsec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC 1" >>confdefs.h fi @@ -48020,7 +48244,7 @@ fi if test "x$ac_cv_member_struct_stat_st_birthtimespec_tv_nsec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC 1" >>confdefs.h else case e in @%:@( @@ -48030,7 +48254,7 @@ else case e in @%:@( if test "x$ac_cv_member_struct_stat_st_birthtimensec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC 1" >>confdefs.h else case e in @%:@( @@ -48040,7 +48264,7 @@ else case e in @%:@( if test "x$ac_cv_member_struct_stat_st_birthtim_tv_nsec" = xyes then : -printf "%s\n" "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC 1" >>confdefs.h fi @@ -48053,7 +48277,7 @@ fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for bool, true, false" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for bool, true, false" >&5 printf %s "checking for bool, true, false... " >&6; } if test ${gl_cv_c_bool+y} then : @@ -48078,11 +48302,11 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_bool" >&5 -printf "%s\n" "$gl_cv_c_bool" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_c_bool" >&5 +printf '%s\n' "$gl_cv_c_bool" >&6; } if test "$gl_cv_c_bool" = yes; then -printf "%s\n" "@%:@define HAVE_C_BOOL 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_C_BOOL 1" >>confdefs.h fi @@ -48284,13 +48508,13 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_FSCANF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FSCANF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_FSCANF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_FSCANF 1" >>confdefs.h @@ -48308,13 +48532,13 @@ printf "%s\n" "@%:@define GNULIB_FSCANF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_SCANF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_SCANF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_SCANF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_SCANF 1" >>confdefs.h @@ -48332,7 +48556,7 @@ printf "%s\n" "@%:@define GNULIB_SCANF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FGETC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FGETC 1" >>confdefs.h @@ -48351,7 +48575,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FGETC 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_GETC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_GETC 1" >>confdefs.h @@ -48370,7 +48594,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_GETC 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_GETCHAR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_GETCHAR 1" >>confdefs.h @@ -48389,7 +48613,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_GETCHAR 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FGETS 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FGETS 1" >>confdefs.h @@ -48408,7 +48632,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FGETS 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FREAD 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FREAD 1" >>confdefs.h @@ -48427,7 +48651,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FREAD 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FPRINTF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FPRINTF 1" >>confdefs.h @@ -48446,7 +48670,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FPRINTF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_PRINTF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_PRINTF 1" >>confdefs.h @@ -48465,7 +48689,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_PRINTF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_VFPRINTF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_VFPRINTF 1" >>confdefs.h @@ -48484,7 +48708,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_VFPRINTF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_VPRINTF 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_VPRINTF 1" >>confdefs.h @@ -48503,7 +48727,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_VPRINTF 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FPUTC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FPUTC 1" >>confdefs.h @@ -48522,7 +48746,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FPUTC 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_PUTC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_PUTC 1" >>confdefs.h @@ -48541,7 +48765,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_PUTC 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_PUTCHAR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_PUTCHAR 1" >>confdefs.h @@ -48560,7 +48784,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_PUTCHAR 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FPUTS 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FPUTS 1" >>confdefs.h @@ -48579,7 +48803,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FPUTS 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_PUTS 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_PUTS 1" >>confdefs.h @@ -48598,7 +48822,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_PUTS 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_FWRITE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_FWRITE 1" >>confdefs.h @@ -48615,7 +48839,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_FWRITE 1" >>confdefs.h if test "$GL_GENERATE_ERRNO_H:$REPLACE_STRERROR_0" = false:0; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working strerror function" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working strerror function" >&5 printf %s "checking for working strerror function... " >&6; } if test ${gl_cv_func_working_strerror+y} then : @@ -48660,8 +48884,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_working_strerror" >&5 -printf "%s\n" "$gl_cv_func_working_strerror" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_working_strerror" >&5 +printf '%s\n' "$gl_cv_func_working_strerror" >&6; } case "$gl_cv_func_working_strerror" in *yes) ;; *) @@ -48689,7 +48913,7 @@ fi -printf "%s\n" "@%:@define GNULIB_STRERROR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_STRERROR 1" >>confdefs.h @@ -48712,7 +48936,7 @@ printf "%s\n" "@%:@define GNULIB_STRERROR 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_TEST_STRERROR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_STRERROR 1" >>confdefs.h @@ -48742,7 +48966,7 @@ fi ac_fn_c_check_header_compile "$LINENO" "winsock2.h" "ac_cv_header_winsock2_h" "$ac_includes_default" if test "x$ac_cv_header_winsock2_h" = xyes then : - printf "%s\n" "@%:@define HAVE_WINSOCK2_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_WINSOCK2_H 1" >>confdefs.h fi @@ -48784,7 +49008,7 @@ fi HAVE_DECL_STRNLEN=0 else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working strnlen" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working strnlen" >&5 printf %s "checking for working strnlen... " >&6; } if test ${ac_cv_func_strnlen_working+y} then : @@ -48792,34 +49016,60 @@ then : else case e in @%:@( e) if test "$cross_compiling" = yes then : - # Guess no on AIX systems, yes otherwise. - case "$host_os" in - aix*) ac_cv_func_strnlen_working=no;; - *) ac_cv_func_strnlen_working=yes;; - esac -else case e in @%:@( - e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext + cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main (void) { - -#define S "foobar" -#define S_LEN (sizeof S - 1) - - /* At least one implementation is buggy: that of AIX 4.3 would - give strnlen (S, 1) == 3. */ - - int i; - for (i = 0; i < S_LEN + 1; ++i) - { - int expected = i <= S_LEN ? i : S_LEN; - if (strnlen (S, i) != expected) - return 1; - } +#if defined _AIX && !defined _AIX51 + #error "AIX pre 5.1 is buggy" + #endif + #ifdef __ANDROID__ + #include + #if __ANDROID_API__ < 22 + #error "Android API < 22 is buggy" + #endif + #endif + + ; return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_func_strnlen_working=yes +else case e in @%:@( + e) ac_cv_func_strnlen_working=no ;; +esac +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +else case e in @%:@( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_includes_default + /* Use pstrnlen to test; 'volatile' prevents the compiler + from optimizing the strnlen calls away. */ + size_t (*volatile pstrnlen) (char const *, size_t) = strnlen; + char const s[] = "foobar"; + int s_len = sizeof s - 1; + +int +main (void) +{ + /* AIX 4.3 is buggy: strnlen (S, 1) == 3. */ + int i; + for (i = 0; i < s_len + 1; ++i) + { + int expected = i <= s_len ? i : s_len; + if (pstrnlen (s, i) != expected) + return 1; + } + + /* Android 5.0 (API 21) strnlen ("", SIZE_MAX) incorrectly crashes. */ + if (pstrnlen ("", -1) != 0) + return 1; ; return 0; } @@ -48838,8 +49088,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strnlen_working" >&5 -printf "%s\n" "$ac_cv_func_strnlen_working" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strnlen_working" >&5 +printf '%s\n' "$ac_cv_func_strnlen_working" >&6; } test $ac_cv_func_strnlen_working = no && : @@ -48887,7 +49137,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_STRNLEN 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_STRNLEN 1" >>confdefs.h @@ -48897,12 +49147,12 @@ printf "%s\n" "@%:@define GNULIB_TEST_STRNLEN 1" >>confdefs.h ac_fn_c_check_func "$LINENO" "strtoul" "ac_cv_func_strtoul" if test "x$ac_cv_func_strtoul" = xyes then : - printf "%s\n" "@%:@define HAVE_STRTOUL 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_STRTOUL 1" >>confdefs.h fi if test $ac_cv_func_strtoul = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether strtoul works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether strtoul works" >&5 printf %s "checking whether strtoul works... " >&6; } if test ${gl_cv_func_strtoul_works+y} then : @@ -48965,8 +49215,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_strtoul_works" >&5 -printf "%s\n" "$gl_cv_func_strtoul_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_strtoul_works" >&5 +printf '%s\n' "$gl_cv_func_strtoul_works" >&6; } case "$gl_cv_func_strtoul_works" in *yes) ;; *) REPLACE_STRTOUL=1 ;; @@ -49004,7 +49254,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_STRTOUL 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_STRTOUL 1" >>confdefs.h @@ -49025,7 +49275,7 @@ printf "%s\n" "@%:@define GNULIB_TEST_STRTOUL 1" >>confdefs.h ac_fn_c_check_header_compile "$LINENO" "sys/single_threaded.h" "ac_cv_header_sys_single_threaded_h" "$ac_includes_default" if test "x$ac_cv_header_sys_single_threaded_h" = xyes then : - printf "%s\n" "@%:@define HAVE_SYS_SINGLE_THREADED_H 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SYS_SINGLE_THREADED_H 1" >>confdefs.h fi @@ -49658,7 +49908,7 @@ fi -printf "%s\n" "@%:@define GNULIB_UNISTR_U8_MBTOUCR 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_UNISTR_U8_MBTOUCR 1" >>confdefs.h @@ -49698,7 +49948,7 @@ fi -printf "%s\n" "@%:@define GNULIB_UNISTR_U8_UCTOMB 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_UNISTR_U8_UCTOMB 1" >>confdefs.h @@ -49833,10 +50083,10 @@ fi -printf "%s\n" "@%:@define GNULIB_STDIO_SINGLE_THREAD 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_STDIO_SINGLE_THREAD 1" >>confdefs.h -printf "%s\n" "@%:@define USE_UNLOCKED_IO GNULIB_STDIO_SINGLE_THREAD" >>confdefs.h +printf '%s\n' "@%:@define USE_UNLOCKED_IO GNULIB_STDIO_SINGLE_THREAD" >>confdefs.h @@ -49856,7 +50106,7 @@ printf "%s\n" "@%:@define USE_UNLOCKED_IO GNULIB_STDIO_SINGLE_THREAD" >>confdefs - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for variable-length arrays" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for variable-length arrays" >&5 printf %s "checking for variable-length arrays... " >&6; } if test ${ac_cv_c_vararrays+y} then : @@ -49926,15 +50176,15 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_vararrays" >&5 -printf "%s\n" "$ac_cv_c_vararrays" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_vararrays" >&5 +printf '%s\n' "$ac_cv_c_vararrays" >&6; } if test "$ac_cv_c_vararrays" = yes; then -printf "%s\n" "@%:@define HAVE_C_VARARRAYS 1" >>confdefs.h +printf '%s\n' "@%:@define HAVE_C_VARARRAYS 1" >>confdefs.h elif test "$ac_cv_c_vararrays" = no; then -printf "%s\n" "@%:@define __STDC_NO_VLA__ 1" >>confdefs.h +printf '%s\n' "@%:@define __STDC_NO_VLA__ 1" >>confdefs.h fi @@ -49971,7 +50221,7 @@ printf "%s\n" "@%:@define __STDC_NO_VLA__ 1" >>confdefs.h ac_fn_check_decl "$LINENO" "wcwidth" "ac_cv_have_decl_wcwidth" " #include -" "$ac_c_undeclared_builtin_options" "CFLAGS" +" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS" if test "x$ac_cv_have_decl_wcwidth" = xyes then : ac_have_decl=1 @@ -49979,14 +50229,14 @@ else case e in @%:@( e) ac_have_decl=0 ;; esac fi -printf "%s\n" "@%:@define HAVE_DECL_WCWIDTH $ac_have_decl" >>confdefs.h +printf '%s\n' "@%:@define HAVE_DECL_WCWIDTH $ac_have_decl" >>confdefs.h if test $ac_cv_have_decl_wcwidth != yes; then HAVE_DECL_WCWIDTH=0 fi if test $ac_cv_func_wcwidth != yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether wcwidth is a macro" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether wcwidth is a macro" >&5 printf %s "checking whether wcwidth is a macro... " >&6; } if test ${gl_cv_func_wcwidth_macro+y} then : @@ -50013,13 +50263,13 @@ rm -rf conftest* ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wcwidth_macro" >&5 -printf "%s\n" "$gl_cv_func_wcwidth_macro" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wcwidth_macro" >&5 +printf '%s\n' "$gl_cv_func_wcwidth_macro" >&6; } fi if test $ac_cv_func_wcwidth = yes || test $gl_cv_func_wcwidth_macro = yes; then HAVE_WCWIDTH=1 - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether wcwidth works reasonably in UTF-8 locales" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether wcwidth works reasonably in UTF-8 locales" >&5 printf %s "checking whether wcwidth works reasonably in UTF-8 locales... " >&6; } if test ${gl_cv_func_wcwidth_works+y} then : @@ -50086,8 +50336,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wcwidth_works" >&5 -printf "%s\n" "$gl_cv_func_wcwidth_works" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_func_wcwidth_works" >&5 +printf '%s\n' "$gl_cv_func_wcwidth_works" >&6; } case "$gl_cv_func_wcwidth_works" in *yes) ;; *no) REPLACE_WCWIDTH=1 ;; @@ -50138,7 +50388,7 @@ fi -printf "%s\n" "@%:@define GNULIB_TEST_WCWIDTH 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_TEST_WCWIDTH 1" >>confdefs.h @@ -50205,12 +50455,12 @@ fi : -printf "%s\n" "@%:@define GNULIB_XALLOC 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_XALLOC 1" >>confdefs.h -printf "%s\n" "@%:@define GNULIB_XALLOC_DIE 1" >>confdefs.h +printf '%s\n' "@%:@define GNULIB_XALLOC_DIE 1" >>confdefs.h # End of code from modules @@ -50267,7 +50517,7 @@ then : else case e in @%:@( e) -printf "%s\n" "@%:@define size_t unsigned int" >>confdefs.h +printf '%s\n' "@%:@define size_t unsigned int" >>confdefs.h ;; esac fi @@ -50275,7 +50525,7 @@ fi ac_fn_c_check_func "$LINENO" "setlocale" "ac_cv_func_setlocale" if test "x$ac_cv_func_setlocale" = xyes then : - printf "%s\n" "@%:@define HAVE_SETLOCALE 1" >>confdefs.h + printf '%s\n' "@%:@define HAVE_SETLOCALE 1" >>confdefs.h fi @@ -50298,7 +50548,7 @@ fi if test $is_woe32dll = yes; then -printf "%s\n" "@%:@define WOE32DLL 1" >>confdefs.h +printf '%s\n' "@%:@define WOE32DLL 1" >>confdefs.h fi @@ -50307,7 +50557,7 @@ fi ac_aux_dir_abs=`cd $ac_aux_dir && pwd` # Extract the first word of "perl", so it can be a program name with args. set dummy perl; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PERL+y} then : @@ -50330,7 +50580,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_path_PERL="$as_dir$ac_word$ac_exec_ext" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -50344,11 +50594,11 @@ esac fi PERL=$ac_cv_path_PERL if test -n "$PERL"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5 -printf "%s\n" "$PERL" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5 +printf '%s\n' "$PERL" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -50371,7 +50621,7 @@ CROSS_COMPILING=$cross_compiling do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CXX+y} then : @@ -50392,7 +50642,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -50404,11 +50654,11 @@ esac fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -printf "%s\n" "$CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf '%s\n' "$CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -50421,7 +50671,7 @@ if test -z "$CXX"; then do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CXX+y} then : @@ -50442,7 +50692,7 @@ do for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -50454,11 +50704,11 @@ esac fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -printf "%s\n" "$ac_ct_CXX" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +printf '%s\n' "$ac_ct_CXX" >&6; } else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 -printf "%s\n" "no" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf '%s\n' "no" >&6; } fi @@ -50470,8 +50720,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CXX=$ac_ct_CXX @@ -50481,7 +50731,7 @@ fi fi fi if test "$CXX" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5 printf %s "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -50495,7 +50745,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then gl_cv_prog_ansicxx_works=yes if (./conftest; exit) 2>/dev/null; then @@ -50513,12 +50763,12 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_works" >&5 -printf "%s\n" "$gl_cv_prog_ansicxx_works" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_works" >&5 +printf '%s\n' "$gl_cv_prog_ansicxx_works" >&6; } if test $gl_cv_prog_ansicxx_works = no; then CXX=no else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports namespaces" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler supports namespaces" >&5 printf %s "checking whether the C++ compiler supports namespaces... " >&6; } ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' @@ -50535,7 +50785,7 @@ EOF if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 (eval $ac_link) 2>&5 ac_status=$? - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && test -s conftest$ac_exeext; then gl_cv_prog_ansicxx_namespaces=yes else @@ -50548,8 +50798,8 @@ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_namespaces" >&5 -printf "%s\n" "$gl_cv_prog_ansicxx_namespaces" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_prog_ansicxx_namespaces" >&5 +printf '%s\n' "$gl_cv_prog_ansicxx_namespaces" >&6; } if test $gl_cv_prog_ansicxx_namespaces = no; then CXX=no fi @@ -50571,7 +50821,7 @@ fi depcc="$CXX" am_compiler_list= -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CXX_dependencies_compiler_type+y} then : @@ -50684,8 +50934,8 @@ fi ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 -printf "%s\n" "$am_cv_CXX_dependencies_compiler_type" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +printf '%s\n' "$am_cv_CXX_dependencies_compiler_type" >&6; } CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type if @@ -50705,7 +50955,7 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_cxx_compiler_gnu - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5 printf %s "checking whether the compiler supports GNU C++... " >&6; } if test ${ac_cv_cxx_compiler_gnu+y} then : @@ -50737,8 +50987,8 @@ ac_cv_cxx_compiler_gnu=$ac_compiler_gnu ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +printf '%s\n' "$ac_cv_cxx_compiler_gnu" >&6; } ac_compiler_gnu=$ac_cv_cxx_compiler_gnu if test $ac_compiler_gnu = yes; then @@ -50748,7 +50998,7 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu fi ac_test_CXXFLAGS=${CXXFLAGS+y} ac_save_CXXFLAGS=$CXXFLAGS -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 printf %s "checking whether $CXX accepts -g... " >&6; } if test ${ac_cv_prog_cxx_g+y} then : @@ -50816,8 +51066,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -printf "%s\n" "$ac_cv_prog_cxx_g" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +printf '%s\n' "$ac_cv_prog_cxx_g" >&6; } if test $ac_test_CXXFLAGS; then CXXFLAGS=$ac_save_CXXFLAGS elif test $ac_cv_prog_cxx_g = yes; then @@ -50853,7 +51103,7 @@ fi LIBSCHED= if test $gl_threads_api = posix; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lrt" >&5 printf %s "checking for sched_yield in -lrt... " >&6; } if test ${ac_cv_lib_rt_sched_yield+y} then : @@ -50894,13 +51144,13 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_rt_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_rt_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_rt_sched_yield" >&6; } if test "x$ac_cv_lib_rt_sched_yield" = xyes then : LIBSCHED=-lrt else case e in @%:@( - e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 + e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sched_yield in -lposix4" >&5 printf %s "checking for sched_yield in -lposix4... " >&6; } if test ${ac_cv_lib_posix4_sched_yield+y} then : @@ -50941,8 +51191,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ LIBS=$ac_check_lib_save_LIBS ;; esac fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 -printf "%s\n" "$ac_cv_lib_posix4_sched_yield" >&6; } +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix4_sched_yield" >&5 +printf '%s\n' "$ac_cv_lib_posix4_sched_yield" >&6; } if test "x$ac_cv_lib_posix4_sched_yield" = xyes then : LIBSCHED=-lposix4 @@ -51043,44 +51293,7 @@ cat >confcache <<\_ACEOF _ACEOF -# The following way of writing the cache mishandles newlines in values, -# but we know of no workaround that is simple, portable, and efficient. -# So, we kill variables containing newlines. -# Ultrix sh set writes to stderr and can't be redirected directly, -# and sets the high bit in the cache file unless we assign to the vars. -( - for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( - *) { eval $ac_var=; unset $ac_var;} ;; - esac ;; - esac - done - - (set) 2>&1 | - case $as_nl`(ac_space=' '; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - # 'set' does not quote correctly, so add quotes: double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \. - sed -n \ - "s/'/'\\\\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" - ;; #( - *) - # 'set' quotes correctly as required by POSIX, so do not add quotes. - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) | +ac_cache_dump | sed ' /^ac_cv_env_/b end t clear @@ -51092,8 +51305,8 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 -printf "%s\n" "$as_me: updating cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +printf '%s\n' "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else @@ -51107,8 +51320,8 @@ printf "%s\n" "$as_me: updating cache $cache_file" >&6;} fi fi else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 -printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +printf '%s\n' "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache @@ -51125,7 +51338,7 @@ U= for ac_i in : $LIB@&t@OBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"` + ac_i=`printf '%s\n' "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" @@ -51136,14 +51349,14 @@ LIB@&t@OBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 printf %s "checking that generated files are newer than configure... " >&6; } if test -n "$am_sleep_pid"; then # Hide warnings about reused PIDs. wait $am_sleep_pid 2>/dev/null fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5 -printf "%s\n" "done" >&6; } + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: done" >&5 +printf '%s\n' "done" >&6; } case $enable_silent_rules in @%:@ ((( yes) AM_DEFAULT_VERBOSITY=0;; no) AM_DEFAULT_VERBOSITY=1;; @@ -51286,13 +51499,21 @@ Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi : "${CONFIG_STATUS=./config.status}" +case $CONFIG_STATUS in @%:@( + -*) : + CONFIG_STATUS=./$CONFIG_STATUS ;; @%:@( + */*) : + ;; @%:@( + *) : + CONFIG_STATUS=./$CONFIG_STATUS ;; +esac + ac_write_fail=0 -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 -printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;} +ac_clean_CONFIG_STATUS='"$CONFIG_STATUS"' +{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +printf '%s\n' "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 -cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +cat >"$CONFIG_STATUS" <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. @@ -51306,7 +51527,7 @@ ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF -cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## @@ -51318,7 +51539,7 @@ then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. + # contradicts POSIX and common usage. Disable this. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case e in @%:@( @@ -51405,7 +51626,7 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi @@ -51421,9 +51642,9 @@ as_fn_error () as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - printf "%s\n" "$as_me: error: $2" >&2 + printf '%s\n' "$as_me: error: $2" >&2 as_fn_exit $as_status } @%:@ as_fn_error @@ -51518,7 +51739,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X/"$0" | +printf '%s\n' X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -51540,29 +51761,6 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits - -# Determine whether it's possible to make 'echo' print without a newline. -# These variables are no longer used directly by Autoconf, but are AC_SUBSTed -# for compatibility with existing Makefiles. -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in @%:@((((( --n*) - case `echo 'xy\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - xy) ECHO_C='\c';; - *) echo `echo ksh88 bug on AIX 6.1` > /dev/null - ECHO_T=' ';; - esac;; -*) - ECHO_N='-n';; -esac - -# For backward compatibility with old third-party macros, we provide -# the shell variables $as_echo and $as_echo_n. New code should use -# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively. -as_@&t@echo='printf %s\n' -as_@&t@echo_n='printf %s' - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -51604,7 +51802,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" @@ -51613,7 +51811,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$as_dir" | +printf '%s\n' X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -51666,19 +51864,19 @@ as_tr_sh="eval sed '$as_sed_sh'" # deprecated exec 6>&1 -## ----------------------------------- ## -## Main body of $CONFIG_STATUS script. ## -## ----------------------------------- ## +## ------------------------------------- ## +## Main body of "$CONFIG_STATUS" script. ## +## ------------------------------------- ## _ASEOF -test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 +test $as_write_fail = 0 && chmod +x "$CONFIG_STATUS" || ac_write_fail=1 -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by gettext-runtime $as_me 0.22.5, which was -generated by GNU Autoconf 2.72. Invocation command line was +generated by GNU Autoconf 2.73. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -51700,7 +51898,7 @@ case $ac_config_headers in *" esac -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" @@ -51708,7 +51906,7 @@ config_commands="$ac_config_commands" _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ '$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files @@ -51740,16 +51938,16 @@ $config_commands Report bugs to ." _ACEOF -ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"` -ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config=`printf '%s\n' "$ac_configure_args" | sed "$ac_safe_unquote"` +ac_cs_config_escaped=`printf '%s\n' "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"` +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ gettext-runtime config.status 0.22.5 -configured by $0, generated by GNU Autoconf 2.72, +configured by $0, generated by GNU Autoconf 2.73, with options \\"\$ac_cs_config\\" -Copyright (C) 2023 Free Software Foundation, Inc. +Copyright (C) 2026 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -51758,10 +51956,14 @@ srcdir='$srcdir' INSTALL='$INSTALL' MKDIR_P='$MKDIR_P' AWK='$AWK' -test -n "\$AWK" || AWK=awk +test -n "\$AWK" || { + awk '' >$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 @@ -51789,15 +51991,15 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - printf "%s\n" "$ac_cs_version"; exit ;; + printf '%s\n' "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) - printf "%s\n" "$ac_cs_config"; exit ;; + printf '%s\n' "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" @@ -51805,7 +52007,7 @@ do --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; @@ -51814,7 +52016,7 @@ do as_fn_error $? "ambiguous option: '$1' Try '$0 --help' for more information.";; --help | --hel | -h ) - printf "%s\n" "$ac_cs_usage"; exit ;; + printf '%s\n' "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; @@ -51838,29 +52040,29 @@ if $ac_cs_silent; then fi _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift - \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 + \printf '%s\n' "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../@%:@@%:@ /;s/...$/ @%:@@%:@/;p;x;p;x' <<_ASBOX @%:@@%:@ Running $as_me. @%:@@%:@ _ASBOX - printf "%s\n" "$ac_log" + printf '%s\n' "$ac_log" } >&5 _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 # # INIT-COMMANDS # @@ -52345,7 +52547,7 @@ fi _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets @@ -52443,13 +52645,13 @@ _ACEOF echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 -ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim_num=`echo "$ac_subst_vars" | sed -n '$='` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 - ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | sed -n '$='` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then @@ -52460,7 +52662,7 @@ for ac_last_try in false false false false false :; do done rm -f conf$$subs.sh -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' @@ -52505,9 +52707,9 @@ t delim N s/\n// } -' >>$CONFIG_STATUS || ac_write_fail=1 +' >>"$CONFIG_STATUS" || ac_write_fail=1 rm -f conf$$subs.awk -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 @@ -52536,7 +52738,7 @@ cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && _ACAWK _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else @@ -52568,7 +52770,7 @@ s/^[^=]*=[ ]*$// }' fi -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. @@ -52639,9 +52841,9 @@ s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 +"/g' >>"$CONFIG_STATUS" || ac_write_fail=1 -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } @@ -52659,8 +52861,12 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { + suffix = P[macro] D[macro] + while (suffix ~ /[\t ]$/) { + suffix = substr(suffix, 1, length(suffix) - 1) + } # Preserve the white space surrounding the "#". - print prefix "define", macro P[macro] D[macro] + print prefix "define", macro suffix next } else { # Replace #undef with comments. This is necessary, for example, @@ -52675,7 +52881,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 { print } _ACAWK _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" @@ -52719,7 +52925,7 @@ do esac || as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;; esac - case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + case $ac_f in *\'*) ac_f=`printf '%s\n' "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done @@ -52727,17 +52933,17 @@ do # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` - printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + printf '%s\n' "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 -printf "%s\n" "$as_me: creating $ac_file" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +printf '%s\n' "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) - ac_sed_conf_input=`printf "%s\n" "$configure_input" | + ac_sed_conf_input=`printf '%s\n' "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac @@ -52754,7 +52960,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$ac_file" | +printf '%s\n' X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -52778,9 +52984,9 @@ printf "%s\n" X"$ac_file" | case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` + ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -52825,7 +53031,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix esac _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= @@ -52842,10 +53048,10 @@ ac_sed_dataroot=' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +printf '%s\n' "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g @@ -52859,11 +53065,11 @@ _ACEOF # Neutralize VPATH when '$srcdir' = '.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t @@ -52887,9 +53093,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&5 -printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' +printf '%s\n' "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" @@ -52905,20 +53111,20 @@ which seems to be undefined. Please make sure it is defined" >&2;} # if test x"$ac_file" != x-; then { - printf "%s\n" "/* $configure_input */" >&1 \ + printf '%s\n' "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 -printf "%s\n" "$as_me: $ac_file is unchanged" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +printf '%s\n' "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else - printf "%s\n" "/* $configure_input */" >&1 \ + printf '%s\n' "/* $configure_input */" >&1 \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi @@ -52938,7 +53144,7 @@ $as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$_am_arg" : 'X\(//\)[^/]' \| \ X"$_am_arg" : 'X\(//\)$' \| \ X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$_am_arg" | +printf '%s\n' X"$_am_arg" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -52958,8 +53164,8 @@ printf "%s\n" X"$_am_arg" | s/.*/./; q'`/stamp-h$_am_stamp_count ;; - :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 -printf "%s\n" "$as_me: executing $ac_file commands" >&6;} + :C) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +printf '%s\n' "$as_me: executing $ac_file commands" >&6;} ;; esac @@ -52985,7 +53191,7 @@ esac for am_mf do # Strip MF so we end up with the name of the file. - am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'` + am_mf=`printf '%s\n' "$am_mf" | sed -e 's/:.*$//'` # Check whether this is an Automake generated Makefile which includes # dependency-tracking related rules and includes. # Grep'ing the whole file directly is not great: AIX grep has a line @@ -52997,7 +53203,7 @@ $as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$am_mf" : 'X\(//\)[^/]' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X"$am_mf" | +printf '%s\n' X"$am_mf" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -53019,7 +53225,7 @@ printf "%s\n" X"$am_mf" | $as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \ X"$am_mf" : 'X\(//\)$' \| \ X"$am_mf" : 'X\(/\)' \| . 2>/dev/null || -printf "%s\n" X/"$am_mf" | +printf '%s\n' X/"$am_mf" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -53044,8 +53250,8 @@ printf "%s\n" X/"$am_mf" | (exit $ac_status); } || am_rc=$? done if test $am_rc -ne 0; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} + { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "Something went wrong bootstrapping makefile fragments for automatic dependency tracking. If GNU make was not used, consider re-running the configure script with MAKE=\"gmake\" (or whatever is @@ -54058,7 +54264,7 @@ done # for ac_tag as_fn_exit 0 _ACEOF -ac_clean_files=$ac_clean_files_save +ac_clean_CONFIG_STATUS= test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 @@ -54074,11 +54280,18 @@ test $ac_write_fail = 0 || # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: + case $CONFIG_STATUS in @%:@( + -*) : + ac_no_opts=-- ;; @%:@( + *) : + ac_no_opts= ;; +esac ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null - $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + $SHELL $ac_no_opts "$CONFIG_STATUS" $ac_config_status_args || + ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. @@ -54124,7 +54337,7 @@ if test "$no_recursion" != yes; then ;; *) case $ac_arg in - *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append ac_sub_configure_args " '$ac_arg'" ;; esac @@ -54134,7 +54347,7 @@ if test "$no_recursion" != yes; then # in subdir configurations. ac_arg="--prefix=$prefix" case $ac_arg in - *\'*) ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + *\'*) ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args" @@ -54155,17 +54368,17 @@ if test "$no_recursion" != yes; then test -d "$srcdir/$ac_dir" || continue ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)" - printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5 - printf "%s\n" "$ac_msg" >&6 + printf '%s\n' "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5 + printf '%s\n' "$ac_msg" >&6 as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'` + ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'` # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; @@ -54202,8 +54415,8 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix elif test -f "$ac_srcdir/configure"; then ac_sub_configure=$ac_srcdir/configure else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5 -printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5 +printf '%s\n' "$as_me: WARNING: no configuration information is in $ac_dir" >&2;} ac_sub_configure= fi @@ -54216,8 +54429,8 @@ printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2; ac_sub_cache_file=$ac_top_build_prefix$cache_file ;; esac - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5 -printf "%s\n" "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5 +printf '%s\n' "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;} # The eval makes quoting arguments work. eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \ --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" || @@ -54228,7 +54441,7 @@ printf "%s\n" "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args - done fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 -printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} + { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi diff --git a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/requests b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/requests index 9a3f116dd5..02ea694267 100644 --- a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/requests +++ b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/requests @@ -1,4 +1,4 @@ -# This file was generated by Autom4te 2.72. +# This file was generated by Autom4te 2.73. # It contains the lists of macros which have been traced. # It can be safely removed. @@ -11,1000 +11,46 @@ ], [ '/usr/share/autoconf/autoconf/autoconf.m4f', - '/usr/share/aclocal-1.18/internal/ac-config-macro-dirs.m4', - '/usr/share/aclocal-1.18/amversion.m4', - '/usr/share/aclocal-1.18/auxdir.m4', - '/usr/share/aclocal-1.18/cond-if.m4', - '/usr/share/aclocal-1.18/cond.m4', - '/usr/share/aclocal-1.18/depend.m4', - '/usr/share/aclocal-1.18/depout.m4', - '/usr/share/aclocal-1.18/init.m4', - '/usr/share/aclocal-1.18/install-sh.m4', - '/usr/share/aclocal-1.18/lead-dot.m4', - '/usr/share/aclocal-1.18/make.m4', - '/usr/share/aclocal-1.18/missing.m4', - '/usr/share/aclocal-1.18/options.m4', - '/usr/share/aclocal-1.18/prog-cc-c-o.m4', - '/usr/share/aclocal-1.18/rmf.m4', - '/usr/share/aclocal-1.18/runlog.m4', - '/usr/share/aclocal-1.18/sanity.m4', - '/usr/share/aclocal-1.18/silent.m4', - '/usr/share/aclocal-1.18/strip.m4', - '/usr/share/aclocal-1.18/substnot.m4', - '/usr/share/aclocal-1.18/tar.m4', - '/usr/share/aclocal-1.18/xargsn.m4', - 'gnulib-m4/00gnulib.m4', - 'gnulib-m4/__inline.m4', - 'gnulib-m4/absolute-header.m4', - 'gnulib-m4/alloca.m4', - 'gnulib-m4/ansi-c++.m4', - 'gnulib-m4/asm-underscore.m4', - 'gnulib-m4/assert_h.m4', - 'gnulib-m4/atexit.m4', - 'gnulib-m4/builtin-expect.m4', - 'gnulib-m4/c-bool.m4', - 'gnulib-m4/calloc.m4', - 'gnulib-m4/canonicalize.m4', - 'gnulib-m4/close.m4', - 'gnulib-m4/codeset.m4', - 'gnulib-m4/csharp.m4', - 'gnulib-m4/csharpcomp.m4', - 'gnulib-m4/double-slash-root.m4', - 'gnulib-m4/dup2.m4', - 'gnulib-m4/eealloc.m4', - 'gnulib-m4/environ.m4', - 'gnulib-m4/errno_h.m4', - 'gnulib-m4/error.m4', - 'gnulib-m4/error_h.m4', - 'gnulib-m4/extensions.m4', - 'gnulib-m4/extern-inline.m4', - 'gnulib-m4/fcntl.m4', - 'gnulib-m4/fcntl_h.m4', - 'gnulib-m4/free.m4', - 'gnulib-m4/fstat.m4', - 'gnulib-m4/getdtablesize.m4', - 'gnulib-m4/getopt.m4', - 'gnulib-m4/getprogname.m4', - 'gnulib-m4/gnulib-common.m4', - 'gnulib-m4/gnulib-comp.m4', - 'gnulib-m4/host-cpu-c-abi.m4', - 'gnulib-m4/iconv_h.m4', - 'gnulib-m4/iconv_open.m4', - 'gnulib-m4/include_next.m4', - 'gnulib-m4/inline.m4', - 'gnulib-m4/intl-thread-locale.m4', - 'gnulib-m4/inttypes.m4', - 'gnulib-m4/iswblank.m4', - 'gnulib-m4/iswdigit.m4', - 'gnulib-m4/iswpunct.m4', - 'gnulib-m4/iswxdigit.m4', - 'gnulib-m4/java.m4', - 'gnulib-m4/javacomp.m4', - 'gnulib-m4/langinfo_h.m4', - 'gnulib-m4/largefile.m4', - 'gnulib-m4/lcmessage.m4', - 'gnulib-m4/lib-ld.m4', - 'gnulib-m4/lib-link.m4', - 'gnulib-m4/lib-prefix.m4', - 'gnulib-m4/libunistring-base.m4', - 'gnulib-m4/limits-h.m4', - 'gnulib-m4/localcharset.m4', - 'gnulib-m4/locale-fr.m4', - 'gnulib-m4/locale-ja.m4', - 'gnulib-m4/locale-zh.m4', - 'gnulib-m4/locale_h.m4', - 'gnulib-m4/localename.m4', - 'gnulib-m4/lock.m4', - 'gnulib-m4/lstat.m4', - 'gnulib-m4/malloc.m4', - 'gnulib-m4/malloca.m4', - 'gnulib-m4/manywarnings.m4', - 'gnulib-m4/mbchar.m4', - 'gnulib-m4/mbiter.m4', - 'gnulib-m4/mbrtoc32.m4', - 'gnulib-m4/mbrtowc.m4', - 'gnulib-m4/mbsinit.m4', - 'gnulib-m4/mbslen.m4', - 'gnulib-m4/mbstate_t.m4', - 'gnulib-m4/memchr.m4', - 'gnulib-m4/memmove.m4', - 'gnulib-m4/mempcpy.m4', - 'gnulib-m4/minmax.m4', - 'gnulib-m4/mmap-anon.m4', - 'gnulib-m4/mode_t.m4', - 'gnulib-m4/msvc-inval.m4', - 'gnulib-m4/msvc-nothrow.m4', - 'gnulib-m4/multiarch.m4', - 'gnulib-m4/musl.m4', - 'gnulib-m4/nocrash.m4', - 'gnulib-m4/off_t.m4', - 'gnulib-m4/open-cloexec.m4', - 'gnulib-m4/open-slash.m4', - 'gnulib-m4/open.m4', - 'gnulib-m4/pathmax.m4', - 'gnulib-m4/pthread_rwlock_rdlock.m4', - 'gnulib-m4/raise.m4', - 'gnulib-m4/rawmemchr.m4', - 'gnulib-m4/readlink.m4', - 'gnulib-m4/realloc.m4', - 'gnulib-m4/reallocarray.m4', - 'gnulib-m4/relocatable-lib.m4', - 'gnulib-m4/relocatable.m4', - 'gnulib-m4/setenv.m4', - 'gnulib-m4/setlocale.m4', - 'gnulib-m4/setlocale_null.m4', - 'gnulib-m4/signal_h.m4', - 'gnulib-m4/signalblocking.m4', - 'gnulib-m4/sigpipe.m4', - 'gnulib-m4/ssize_t.m4', - 'gnulib-m4/stat-time.m4', - 'gnulib-m4/stat.m4', - 'gnulib-m4/stdalign.m4', - 'gnulib-m4/stddef_h.m4', - 'gnulib-m4/stdint.m4', - 'gnulib-m4/stdio_h.m4', - 'gnulib-m4/stdlib_h.m4', - 'gnulib-m4/strerror.m4', - 'gnulib-m4/string_h.m4', - 'gnulib-m4/strnlen.m4', - 'gnulib-m4/strtoul.m4', - 'gnulib-m4/sys_socket_h.m4', - 'gnulib-m4/sys_stat_h.m4', - 'gnulib-m4/sys_types_h.m4', - 'gnulib-m4/threadlib.m4', - 'gnulib-m4/time_h.m4', - 'gnulib-m4/uchar_h.m4', - 'gnulib-m4/unicase_h.m4', - 'gnulib-m4/unictype_h.m4', - 'gnulib-m4/uninorm_h.m4', - 'gnulib-m4/unistd_h.m4', - 'gnulib-m4/unlocked-io.m4', - 'gnulib-m4/warn-on-use.m4', - 'gnulib-m4/warnings.m4', - 'gnulib-m4/wchar_h.m4', - 'gnulib-m4/wchar_t.m4', - 'gnulib-m4/wctype_h.m4', - 'gnulib-m4/wcwidth.m4', - 'gnulib-m4/wint_t.m4', - 'gnulib-m4/xalloc.m4', - 'gnulib-m4/zzgnulib.m4', - '../m4/fixautomake.m4', - '../m4/more-warnings.m4', - '../m4/woe32-dll.m4', - 'm4/build-to-host.m4', - 'm4/fcntl-o.m4', - 'm4/flexmember.m4', - 'm4/gettext.m4', - 'm4/iconv.m4', - 'm4/intlmacosx.m4', - 'm4/nls.m4', - 'm4/po.m4', - 'm4/progtest.m4', - 'm4/visibility.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltargz.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltsugar.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltversion.m4', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4', + 'aclocal.m4', 'configure.ac' ], { - 'AC_CHECK_INCLUDES_DEFAULT' => 1, - 'AC_CHECK_LIBM' => 1, + 'AC_CANONICAL_BUILD' => 1, + 'AC_CANONICAL_HOST' => 1, + 'AC_CANONICAL_SYSTEM' => 1, + 'AC_CANONICAL_TARGET' => 1, + 'AC_CONFIG_AUX_DIR' => 1, + 'AC_CONFIG_FILES' => 1, + 'AC_CONFIG_HEADERS' => 1, + 'AC_CONFIG_LIBOBJ_DIR' => 1, + 'AC_CONFIG_LINKS' => 1, 'AC_CONFIG_MACRO_DIR' => 1, 'AC_CONFIG_MACRO_DIR_TRACE' => 1, - 'AC_C_FLEXIBLE_ARRAY_MEMBER' => 1, - 'AC_C_RESTRICT' => 1, - 'AC_DEFUN' => 1, - 'AC_DEFUN_ONCE' => 1, - 'AC_DEPLIBS_CHECK_METHOD' => 1, - 'AC_DISABLE_FAST_INSTALL' => 1, - 'AC_DISABLE_SHARED' => 1, - 'AC_DISABLE_STATIC' => 1, - 'AC_ENABLE_FAST_INSTALL' => 1, - 'AC_ENABLE_SHARED' => 1, - 'AC_ENABLE_STATIC' => 1, - 'AC_FUNC_MBRTOWC' => 1, - 'AC_HEADER_MAJOR' => 1, - 'AC_LIBLTDL_CONVENIENCE' => 1, - 'AC_LIBLTDL_INSTALLABLE' => 1, - 'AC_LIBTOOL_COMPILER_OPTION' => 1, - 'AC_LIBTOOL_CONFIG' => 1, - 'AC_LIBTOOL_CXX' => 1, - 'AC_LIBTOOL_DLOPEN' => 1, - 'AC_LIBTOOL_DLOPEN_SELF' => 1, - 'AC_LIBTOOL_F77' => 1, - 'AC_LIBTOOL_FC' => 1, - 'AC_LIBTOOL_GCJ' => 1, - 'AC_LIBTOOL_LANG_CXX_CONFIG' => 1, - 'AC_LIBTOOL_LANG_C_CONFIG' => 1, - 'AC_LIBTOOL_LANG_F77_CONFIG' => 1, - 'AC_LIBTOOL_LANG_GCJ_CONFIG' => 1, - 'AC_LIBTOOL_LANG_RC_CONFIG' => 1, - 'AC_LIBTOOL_LINKER_OPTION' => 1, - 'AC_LIBTOOL_OBJDIR' => 1, - 'AC_LIBTOOL_PICMODE' => 1, - 'AC_LIBTOOL_POSTDEP_PREDEP' => 1, - 'AC_LIBTOOL_PROG_CC_C_O' => 1, - 'AC_LIBTOOL_PROG_COMPILER_NO_RTTI' => 1, - 'AC_LIBTOOL_PROG_COMPILER_PIC' => 1, - 'AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH' => 1, - 'AC_LIBTOOL_PROG_LD_SHLIBS' => 1, - 'AC_LIBTOOL_RC' => 1, - 'AC_LIBTOOL_SETUP' => 1, - 'AC_LIBTOOL_SYS_DYNAMIC_LINKER' => 1, - 'AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE' => 1, - 'AC_LIBTOOL_SYS_HARD_LINK_LOCKS' => 1, - 'AC_LIBTOOL_SYS_LIB_STRIP' => 1, - 'AC_LIBTOOL_SYS_MAX_CMD_LEN' => 1, - 'AC_LIBTOOL_SYS_OLD_ARCHIVE' => 1, - 'AC_LIBTOOL_WIN32_DLL' => 1, - 'AC_LIB_APPENDTOVAR' => 1, - 'AC_LIB_FROMPACKAGE' => 1, + 'AC_CONFIG_SUBDIRS' => 1, + 'AC_DEFINE_TRACE_LITERAL' => 1, + 'AC_FC_FREEFORM' => 1, + 'AC_FC_PP_DEFINE' => 1, + 'AC_FC_PP_SRCEXT' => 1, + 'AC_FC_SRCEXT' => 1, + 'AC_INIT' => 1, + 'AC_LIBSOURCE' => 1, 'AC_LIB_HAVE_LINKFLAGS' => 1, - 'AC_LIB_LIBPATH' => 1, 'AC_LIB_LINKFLAGS' => 1, - 'AC_LIB_LINKFLAGS_BODY' => 1, 'AC_LIB_LINKFLAGS_FROM_LIBS' => 1, - 'AC_LIB_LTDL' => 1, - 'AC_LIB_PREFIX' => 1, - 'AC_LIB_PREPARE_MULTILIB' => 1, - 'AC_LIB_PREPARE_PREFIX' => 1, - 'AC_LIB_PROG_LD' => 1, - 'AC_LIB_PROG_LD_GNU' => 1, - 'AC_LIB_RPATH' => 1, - 'AC_LIB_WITH_FINAL_PREFIX' => 1, - 'AC_LTDL_DLLIB' => 1, - 'AC_LTDL_DLSYM_USCORE' => 1, - 'AC_LTDL_ENABLE_INSTALL' => 1, - 'AC_LTDL_OBJDIR' => 1, - 'AC_LTDL_PREOPEN' => 1, - 'AC_LTDL_SHLIBEXT' => 1, - 'AC_LTDL_SHLIBPATH' => 1, - 'AC_LTDL_SYMBOL_USCORE' => 1, - 'AC_LTDL_SYSSEARCHPATH' => 1, - 'AC_LTDL_SYS_DLOPEN_DEPLIBS' => 1, - 'AC_PATH_MAGIC' => 1, - 'AC_PATH_TOOL_PREFIX' => 1, - 'AC_PROG_EGREP' => 1, - 'AC_PROG_LD' => 1, - 'AC_PROG_LD_GNU' => 1, - 'AC_PROG_LD_RELOAD_FLAG' => 1, 'AC_PROG_LIBTOOL' => 1, - 'AC_PROG_NM' => 1, - 'AC_SYS_LARGEFILE' => 1, - 'AC_SYS_YEAR2038' => 1, - 'AC_SYS_YEAR2038_RECOMMENDED' => 1, - 'AC_TYPE_MBSTATE_T' => 1, - 'AC_USE_SYSTEM_EXTENSIONS' => 1, - 'AC_WITH_LTDL' => 1, + 'AC_REQUIRE_AUX_FILE' => 1, + 'AC_SUBST' => 1, + 'AC_SUBST_TRACE' => 1, + 'AH_OUTPUT' => 1, 'AM_AUTOMAKE_VERSION' => 1, - 'AM_AUX_DIR_EXPAND' => 1, 'AM_CONDITIONAL' => 1, - 'AM_COND_IF' => 1, - 'AM_DEP_TRACK' => 1, - 'AM_DISABLE_SHARED' => 1, - 'AM_DISABLE_STATIC' => 1, - 'AM_ENABLE_SHARED' => 1, - 'AM_ENABLE_STATIC' => 1, + 'AM_ENABLE_MULTILIB' => 1, + 'AM_EXTRA_RECURSIVE_TARGETS' => 1, 'AM_GNU_GETTEXT' => 1, - 'AM_GNU_GETTEXT_NEED' => 1, + 'AM_GNU_GETTEXT_INTL_SUBDIR' => 1, 'AM_GNU_GETTEXT_REQUIRE_VERSION' => 1, 'AM_GNU_GETTEXT_VERSION' => 1, 'AM_ICONV' => 1, - 'AM_ICONV_LINK' => 1, - 'AM_ICONV_LINKFLAGS_BODY' => 1, - 'AM_INIT_AUTOMAKE' => 1, - 'AM_LANGINFO_CODESET' => 1, - 'AM_MAKE_INCLUDE' => 1, - 'AM_MISSING_HAS_RUN' => 1, - 'AM_MISSING_PROG' => 1, - 'AM_NLS' => 1, - 'AM_OUTPUT_DEPENDENCY_COMMANDS' => 1, - 'AM_PATH_PROG_WITH_TEST' => 1, - 'AM_POSTPROCESS_PO_MAKEFILE' => 1, - 'AM_PO_SUBDIRS' => 1, - 'AM_PROG_CC_C_O' => 1, - 'AM_PROG_INSTALL_SH' => 1, - 'AM_PROG_INSTALL_STRIP' => 1, - 'AM_PROG_LD' => 1, - 'AM_PROG_LIBTOOL' => 1, - 'AM_PROG_NM' => 1, - 'AM_RUN_LOG' => 1, - 'AM_SANITY_CHECK' => 1, - 'AM_SET_CURRENT_AUTOMAKE_VERSION' => 1, - 'AM_SET_DEPDIR' => 1, - 'AM_SET_LEADING_DOT' => 1, - 'AM_SILENT_RULES' => 1, - 'AM_SUBST_NOTMAKE' => 1, - 'AM_XGETTEXT_OPTION' => 1, - 'AM_XGETTEXT_OPTION_INIT' => 1, - 'AU_DEFUN' => 1, - 'FIX_MAKEFILE_DISTRIB' => 1, - 'FIX_MAKEFILE_TOPDIR_DISTRIB' => 1, - 'GL_MDA_DEFINES' => 1, - 'GL_NOCRASH' => 1, - 'LTDL_CONVENIENCE' => 1, - 'LTDL_INIT' => 1, - 'LTDL_INSTALLABLE' => 1, - 'LTOBSOLETE_VERSION' => 1, - 'LTOPTIONS_VERSION' => 1, - 'LTSUGAR_VERSION' => 1, - 'LTVERSION_VERSION' => 1, - 'LT_AC_PROG_EGREP' => 1, - 'LT_AC_PROG_GCJ' => 1, - 'LT_AC_PROG_RC' => 1, - 'LT_AC_PROG_SED' => 1, - 'LT_CMD_MAX_LEN' => 1, - 'LT_CONFIG_LTDL_DIR' => 1, - 'LT_FUNC_ARGZ' => 1, - 'LT_FUNC_DLSYM_USCORE' => 1, - 'LT_INIT' => 1, - 'LT_LANG' => 1, - 'LT_LIB_DLLOAD' => 1, - 'LT_LIB_M' => 1, - 'LT_OUTPUT' => 1, - 'LT_PATH_LD' => 1, - 'LT_PATH_NM' => 1, - 'LT_PROG_GCJ' => 1, - 'LT_PROG_GO' => 1, - 'LT_PROG_RC' => 1, - 'LT_SUPPORTED_TAG' => 1, - 'LT_SYS_DLOPEN_DEPLIBS' => 1, - 'LT_SYS_DLOPEN_SELF' => 1, - 'LT_SYS_DLSEARCH_PATH' => 1, - 'LT_SYS_MODULE_EXT' => 1, - 'LT_SYS_MODULE_PATH' => 1, - 'LT_SYS_SYMBOL_USCORE' => 1, - 'LT_WITH_LTDL' => 1, - '_AC_AM_CONFIG_HEADER_HOOK' => 1, - '_AC_FUNC_CALLOC_IF' => 1, - '_AC_FUNC_MALLOC_IF' => 1, - '_AC_FUNC_REALLOC_IF' => 1, - '_AC_PROG_LIBTOOL' => 1, - '_AC_SYS_LARGEFILE_PROBE' => 1, - '_AC_SYS_YEAR2038_PROBE' => 1, - '_AC_SYS_YEAR2038_TEST_CODE' => 1, - '_AM_AUTOCONF_VERSION' => 1, - '_AM_CONFIG_MACRO_DIRS' => 1, - '_AM_DEPENDENCIES' => 1, - '_AM_FILESYSTEM_TIMESTAMP_RESOLUTION' => 1, - '_AM_IF_OPTION' => 1, - '_AM_MANGLE_OPTION' => 1, - '_AM_OUTPUT_DEPENDENCY_COMMANDS' => 1, - '_AM_PROG_CC_C_O' => 1, - '_AM_PROG_RM_F' => 1, - '_AM_PROG_TAR' => 1, - '_AM_PROG_XARGS_N' => 1, - '_AM_SET_OPTION' => 1, - '_AM_SET_OPTIONS' => 1, - '_AM_SILENT_RULES' => 1, - '_AM_SLEEP_FRACTIONAL_SECONDS' => 1, - '_AM_SUBST_NOTMAKE' => 1, - '_GL_MDA_DEFINES' => 1, - '_LTDL_SETUP' => 1, - '_LT_AC_CHECK_DLFCN' => 1, - '_LT_AC_FILE_LTDLL_C' => 1, - '_LT_AC_LANG_CXX' => 1, - '_LT_AC_LANG_CXX_CONFIG' => 1, - '_LT_AC_LANG_C_CONFIG' => 1, - '_LT_AC_LANG_F77' => 1, - '_LT_AC_LANG_F77_CONFIG' => 1, - '_LT_AC_LANG_GCJ' => 1, - '_LT_AC_LANG_GCJ_CONFIG' => 1, - '_LT_AC_LANG_RC_CONFIG' => 1, - '_LT_AC_LOCK' => 1, - '_LT_AC_PROG_CXXCPP' => 1, - '_LT_AC_PROG_ECHO_BACKSLASH' => 1, - '_LT_AC_SHELL_INIT' => 1, - '_LT_AC_SYS_COMPILER' => 1, - '_LT_AC_SYS_LIBPATH_AIX' => 1, - '_LT_AC_TAGCONFIG' => 1, - '_LT_AC_TAGVAR' => 1, - '_LT_AC_TRY_DLOPEN_SELF' => 1, - '_LT_CC_BASENAME' => 1, - '_LT_COMPILER_BOILERPLATE' => 1, - '_LT_COMPILER_OPTION' => 1, - '_LT_DLL_DEF_P' => 1, - '_LT_LIBOBJ' => 1, - '_LT_LINKER_BOILERPLATE' => 1, - '_LT_LINKER_OPTION' => 1, - '_LT_PATH_TOOL_PREFIX' => 1, - '_LT_PREPARE_SED_QUOTE_VARS' => 1, - '_LT_PROG_CXX' => 1, - '_LT_PROG_ECHO_BACKSLASH' => 1, - '_LT_PROG_F77' => 1, - '_LT_PROG_FC' => 1, - '_LT_PROG_LTMAIN' => 1, - '_LT_REQUIRED_DARWIN_CHECKS' => 1, - '_LT_WITH_SYSROOT' => 1, - '_m4_warn' => 1, - 'gl_00GNULIB' => 1, - 'gl_ABSOLUTE_HEADER' => 1, - 'gl_ABSOLUTE_HEADER_ONE' => 1, - 'gl_ALIGNASOF' => 1, - 'gl_ANSI_CXX' => 1, - 'gl_ANYTHREADLIB_EARLY' => 1, - 'gl_ASM_SYMBOL_PREFIX' => 1, - 'gl_ASSERT_H' => 1, - 'gl_ASSERT_NO_GNULIB_POSIXCHECK' => 1, - 'gl_ASSERT_NO_GNULIB_TESTS' => 1, - 'gl_AVOID_WINPTHREAD' => 1, - 'gl_BIGENDIAN' => 1, - 'gl_BUILD_TO_HOST' => 1, - 'gl_BUILD_TO_HOST_INIT' => 1, - 'gl_CACHE_VAL_SILENT' => 1, - 'gl_CANONICALIZE_LGPL' => 1, - 'gl_CANONICALIZE_LGPL_SEPARATE' => 1, - 'gl_CC_ALLOW_WARNINGS' => 1, - 'gl_CC_GNULIB_WARNINGS' => 1, - 'gl_CC_INHIBIT_WARNINGS' => 1, - 'gl_CHECK_FUNCS_ANDROID' => 1, - 'gl_CHECK_FUNCS_ANDROID_MACOS' => 1, - 'gl_CHECK_FUNCS_CASE_FOR_ANDROID' => 1, - 'gl_CHECK_FUNCS_CASE_FOR_MACOS' => 1, - 'gl_CHECK_FUNCS_DEFAULT_CASE' => 1, - 'gl_CHECK_FUNCS_MACOS' => 1, - 'gl_CHECK_FUNCS_SET_RESULTS' => 1, - 'gl_CHECK_FUNC_MBRTOC32' => 1, - 'gl_CHECK_MALLOC_POSIX' => 1, - 'gl_CHECK_MALLOC_PTRDIFF' => 1, - 'gl_CHECK_NEXT_HEADERS' => 1, - 'gl_CHECK_TYPES_SIGNED' => 1, - 'gl_CHECK_TYPE_SIGSET_T' => 1, - 'gl_CHECK_TYPE_STRUCT_TIMESPEC' => 1, - 'gl_COMMON' => 1, - 'gl_COMMON_BODY' => 1, - 'gl_COMPILER_CLANG' => 1, - 'gl_COMPILER_OPTION_IF' => 1, - 'gl_COMPILER_PREPARE_CHECK_DECL' => 1, - 'gl_CONDITIONAL' => 1, - 'gl_CONDITIONAL_HEADER' => 1, - 'gl_CXX_ALLOW_WARNINGS' => 1, - 'gl_CXX_CHOICE' => 1, - 'gl_CXX_INHIBIT_WARNINGS' => 1, - 'gl_C_ASM' => 1, - 'gl_C_BOOL' => 1, - 'gl_DISABLE_THREADS' => 1, - 'gl_DOUBLE_SLASH_ROOT' => 1, - 'gl_EARLY' => 1, - 'gl_EEALLOC' => 1, - 'gl_EEMALLOC' => 1, - 'gl_EEREALLOC' => 1, - 'gl_ENVIRON' => 1, - 'gl_ERROR' => 1, - 'gl_ERROR_H' => 1, - 'gl_EXTERN_INLINE' => 1, - 'gl_FCNTL_H' => 1, - 'gl_FCNTL_H_DEFAULTS' => 1, - 'gl_FCNTL_H_REQUIRE_DEFAULTS' => 1, - 'gl_FCNTL_MODULE_INDICATOR' => 1, - 'gl_FCNTL_O_FLAGS' => 1, - 'gl_FEATURES_H' => 1, - 'gl_FILE_LIST' => 1, - 'gl_FUNC_ALLOCA' => 1, - 'gl_FUNC_ATEXIT' => 1, - 'gl_FUNC_CALLOC_GNU' => 1, - 'gl_FUNC_CALLOC_POSIX' => 1, - 'gl_FUNC_CANONICALIZE_FILENAME_MODE' => 1, - 'gl_FUNC_CLOSE' => 1, - 'gl_FUNC_DUP2' => 1, - 'gl_FUNC_FCNTL' => 1, - 'gl_FUNC_FREE' => 1, - 'gl_FUNC_FSTAT' => 1, - 'gl_FUNC_GETDTABLESIZE' => 1, - 'gl_FUNC_GETOPT_GNU' => 1, - 'gl_FUNC_GETOPT_POSIX' => 1, - 'gl_FUNC_GETPROGNAME' => 1, - 'gl_FUNC_GLIBC_UNLOCKED_IO' => 1, - 'gl_FUNC_ICONV_OPEN' => 1, - 'gl_FUNC_ISWBLANK' => 1, - 'gl_FUNC_ISWDIGIT' => 1, - 'gl_FUNC_ISWPUNCT' => 1, - 'gl_FUNC_ISWXDIGIT' => 1, - 'gl_FUNC_LSTAT' => 1, - 'gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK' => 1, - 'gl_FUNC_MALLOC_GNU' => 1, - 'gl_FUNC_MALLOC_POSIX' => 1, - 'gl_FUNC_MALLOC_PTRDIFF' => 1, - 'gl_FUNC_MBRTOC32' => 1, - 'gl_FUNC_MBRTOWC' => 1, - 'gl_FUNC_MBSINIT' => 1, - 'gl_FUNC_MBSLEN' => 1, - 'gl_FUNC_MEMCHR' => 1, - 'gl_FUNC_MEMMOVE' => 1, - 'gl_FUNC_MEMPCPY' => 1, - 'gl_FUNC_MMAP_ANON' => 1, - 'gl_FUNC_OPEN' => 1, - 'gl_FUNC_RAISE' => 1, - 'gl_FUNC_RAWMEMCHR' => 1, - 'gl_FUNC_READLINK' => 1, - 'gl_FUNC_READLINK_SEPARATE' => 1, - 'gl_FUNC_REALLOCARRAY' => 1, - 'gl_FUNC_REALLOC_GNU' => 1, - 'gl_FUNC_REALLOC_POSIX' => 1, - 'gl_FUNC_REALPATH_WORKS' => 1, - 'gl_FUNC_SETENV' => 1, - 'gl_FUNC_SETENV_SEPARATE' => 1, - 'gl_FUNC_SETLOCALE' => 1, - 'gl_FUNC_SETLOCALE_NULL' => 1, - 'gl_FUNC_STAT' => 1, - 'gl_FUNC_STRERROR' => 1, - 'gl_FUNC_STRERROR_0' => 1, - 'gl_FUNC_STRNLEN' => 1, - 'gl_FUNC_STRTOUL' => 1, - 'gl_FUNC_UNSETENV' => 1, - 'gl_FUNC_WCWIDTH' => 1, - 'gl_GETOPT_CHECK_HEADERS' => 1, - 'gl_GETOPT_SUBSTITUTE_HEADER' => 1, - 'gl_HAVE_MODULE_HAVELIB' => 1, - 'gl_HEADER_ERRNO_H' => 1, - 'gl_HOST_CPU_C_ABI' => 1, - 'gl_HOST_CPU_C_ABI_32BIT' => 1, - 'gl_ICONV_H' => 1, - 'gl_ICONV_H_DEFAULTS' => 1, - 'gl_ICONV_H_REQUIRE_DEFAULTS' => 1, - 'gl_ICONV_MODULE_INDICATOR' => 1, - 'gl_INCLUDE_NEXT' => 1, - 'gl_INIT' => 1, - 'gl_INLINE' => 1, - 'gl_INTEGER_TYPE_SUFFIX' => 1, - 'gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION' => 1, - 'gl_INTTYPES_H' => 1, - 'gl_INTTYPES_H_DEFAULTS' => 1, - 'gl_INTTYPES_H_REQUIRE_DEFAULTS' => 1, - 'gl_INTTYPES_INCOMPLETE' => 1, - 'gl_INTTYPES_MODULE_INDICATOR' => 1, - 'gl_INTTYPES_PRI_SCN' => 1, - 'gl_LANGINFO_H' => 1, - 'gl_LANGINFO_H_DEFAULTS' => 1, - 'gl_LANGINFO_H_REQUIRE_DEFAULTS' => 1, - 'gl_LANGINFO_MODULE_INDICATOR' => 1, - 'gl_LARGEFILE' => 1, - 'gl_LIBOBJ' => 1, - 'gl_LIBSOURCES' => 1, - 'gl_LIBUNISTRING_LIBHEADER' => 1, - 'gl_LIBUNISTRING_LIB_PREPARE' => 1, - 'gl_LIBUNISTRING_MODULE' => 1, - 'gl_LIBUNISTRING_MODULE_WITH_VARIABLE' => 1, - 'gl_LIBUNISTRING_VERSION_CMP' => 1, - 'gl_LIMITS_H' => 1, - 'gl_LOCALCHARSET' => 1, - 'gl_LOCALENAME_UNSAFE' => 1, - 'gl_LOCALENAME_UNSAFE_LIMITED' => 1, - 'gl_LOCALE_H' => 1, - 'gl_LOCALE_H_DEFAULTS' => 1, - 'gl_LOCALE_H_REQUIRE_DEFAULTS' => 1, - 'gl_LOCALE_MODULE_INDICATOR' => 1, - 'gl_LOCALE_T' => 1, - 'gl_LOCK' => 1, - 'gl_MALLOCA' => 1, - 'gl_MANYWARN_ALL_GCC' => 1, - 'gl_MANYWARN_ALL_GCC(C)' => 1, - 'gl_MANYWARN_ALL_GCC(C++)' => 1, - 'gl_MANYWARN_COMPLEMENT' => 1, - 'gl_MBCHAR' => 1, - 'gl_MBITER' => 1, - 'gl_MBRTOC32_C_LOCALE' => 1, - 'gl_MBRTOC32_EMPTY_INPUT' => 1, - 'gl_MBRTOC32_SANITYCHECK' => 1, - 'gl_MBRTOWC_C_LOCALE' => 1, - 'gl_MBRTOWC_EMPTY_INPUT' => 1, - 'gl_MBRTOWC_INCOMPLETE_STATE' => 1, - 'gl_MBRTOWC_NULL_ARG1' => 1, - 'gl_MBRTOWC_NULL_ARG2' => 1, - 'gl_MBRTOWC_NUL_RETVAL' => 1, - 'gl_MBRTOWC_RETVAL' => 1, - 'gl_MBRTOWC_SANITYCHECK' => 1, - 'gl_MBRTOWC_STORES_INCOMPLETE' => 1, - 'gl_MBSTATE_T_BROKEN' => 1, - 'gl_MINMAX' => 1, - 'gl_MINMAX_IN_HEADER' => 1, - 'gl_MODULE_INDICATOR' => 1, - 'gl_MODULE_INDICATOR_FOR_TESTS' => 1, - 'gl_MODULE_INDICATOR_INIT_VARIABLE' => 1, - 'gl_MODULE_INDICATOR_SET_VARIABLE' => 1, - 'gl_MODULE_INDICATOR_SET_VARIABLE_AUX' => 1, - 'gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR' => 1, - 'gl_MSVC_INVAL' => 1, - 'gl_MSVC_NOTHROW' => 1, - 'gl_MULTIARCH' => 1, - 'gl_MUSL_LIBC' => 1, - 'gl_NEXT_HEADERS' => 1, - 'gl_NEXT_HEADERS_INTERNAL' => 1, - 'gl_OPEN_TRAILING_SLASH_BUG' => 1, - 'gl_PATHMAX' => 1, - 'gl_PATHMAX_SNIPPET' => 1, - 'gl_PATHMAX_SNIPPET_PREREQ' => 1, - 'gl_PREPARE_CHECK_FUNCS_MACOS' => 1, - 'gl_PREPROC_O_CLOEXEC' => 1, - 'gl_PREREQ_ALLOCA' => 1, - 'gl_PREREQ_ATEXIT' => 1, - 'gl_PREREQ_DUP2' => 1, - 'gl_PREREQ_ERROR' => 1, - 'gl_PREREQ_FREE' => 1, - 'gl_PREREQ_FSTAT' => 1, - 'gl_PREREQ_GETDTABLESIZE' => 1, - 'gl_PREREQ_GETPROGNAME' => 1, - 'gl_PREREQ_LOCK' => 1, - 'gl_PREREQ_LSTAT' => 1, - 'gl_PREREQ_MBRTOC32' => 1, - 'gl_PREREQ_MBRTOWC' => 1, - 'gl_PREREQ_MBSINIT' => 1, - 'gl_PREREQ_MBTOWC_LOCK' => 1, - 'gl_PREREQ_MEMCHR' => 1, - 'gl_PREREQ_MEMMOVE' => 1, - 'gl_PREREQ_MEMPCPY' => 1, - 'gl_PREREQ_MINMAX' => 1, - 'gl_PREREQ_OPEN' => 1, - 'gl_PREREQ_RAISE' => 1, - 'gl_PREREQ_RAWMEMCHR' => 1, - 'gl_PREREQ_READLINK' => 1, - 'gl_PREREQ_REALLOCARRAY' => 1, - 'gl_PREREQ_SETENV' => 1, - 'gl_PREREQ_SETLOCALE' => 1, - 'gl_PREREQ_SETLOCALE_LOCK' => 1, - 'gl_PREREQ_SIGPROCMASK' => 1, - 'gl_PREREQ_STAT' => 1, - 'gl_PREREQ_STAT_W32' => 1, - 'gl_PREREQ_STRNLEN' => 1, - 'gl_PREREQ_SYS_H_SOCKET' => 1, - 'gl_PREREQ_SYS_H_WINSOCK2' => 1, - 'gl_PREREQ_SYS_H_WS2TCPIP' => 1, - 'gl_PREREQ_UNSETENV' => 1, - 'gl_PREREQ_WCWIDTH' => 1, - 'gl_PROG_ANSI_CXX' => 1, - 'gl_PROG_AR_RANLIB' => 1, - 'gl_PROG_CC_C99' => 1, - 'gl_PROMOTED_TYPE_MODE_T' => 1, - 'gl_PTHREADLIB' => 1, - 'gl_PTHREADLIB_BODY' => 1, - 'gl_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER' => 1, - 'gl_RELOCATABLE' => 1, - 'gl_RELOCATABLE_BODY' => 1, - 'gl_RELOCATABLE_LIBRARY' => 1, - 'gl_RELOCATABLE_LIBRARY_BODY' => 1, - 'gl_RELOCATABLE_NOP' => 1, - 'gl_REPLACE_ERRNO_VALUE' => 1, - 'gl_REPLACE_FCNTL' => 1, - 'gl_REPLACE_FUNCS' => 1, - 'gl_REPLACE_ICONV_H' => 1, - 'gl_REPLACE_ICONV_OPEN' => 1, - 'gl_REPLACE_LIMITS_H' => 1, - 'gl_SET_LARGEFILE_SOURCE' => 1, - 'gl_SIGNALBLOCKING' => 1, - 'gl_SIGNAL_H' => 1, - 'gl_SIGNAL_H_DEFAULTS' => 1, - 'gl_SIGNAL_H_REQUIRE_DEFAULTS' => 1, - 'gl_SIGNAL_MODULE_INDICATOR' => 1, - 'gl_SIGNAL_SIGPIPE' => 1, - 'gl_SIGNAL_SIGPIPE_BODY' => 1, - 'gl_SILENT' => 1, - 'gl_STAT_BIRTHTIME' => 1, - 'gl_STAT_TIME' => 1, - 'gl_STDALIGN_H' => 1, - 'gl_STDDEF_H' => 1, - 'gl_STDDEF_H_DEFAULTS' => 1, - 'gl_STDDEF_H_REQUIRE_DEFAULTS' => 1, - 'gl_STDDEF_MODULE_INDICATOR' => 1, - 'gl_STDINT_BITSIZEOF' => 1, - 'gl_STDINT_H' => 1, - 'gl_STDINT_INCLUDES' => 1, - 'gl_STDINT_TYPE_PROPERTIES' => 1, - 'gl_STDIO_H' => 1, - 'gl_STDIO_H_DEFAULTS' => 1, - 'gl_STDIO_H_EARLY' => 1, - 'gl_STDIO_H_REQUIRE_DEFAULTS' => 1, - 'gl_STDIO_MODULE_INDICATOR' => 1, - 'gl_STDLIB_H' => 1, - 'gl_STDLIB_H_DEFAULTS' => 1, - 'gl_STDLIB_H_REQUIRE_DEFAULTS' => 1, - 'gl_STDLIB_MODULE_INDICATOR' => 1, - 'gl_STDTHREADLIB' => 1, - 'gl_STDTHREADLIB_BODY' => 1, - 'gl_STRING_H' => 1, - 'gl_STRING_H_DEFAULTS' => 1, - 'gl_STRING_H_REQUIRE_DEFAULTS' => 1, - 'gl_STRING_MODULE_INDICATOR' => 1, - 'gl_SYS_SOCKET_H' => 1, - 'gl_SYS_SOCKET_H_DEFAULTS' => 1, - 'gl_SYS_SOCKET_H_REQUIRE_DEFAULTS' => 1, - 'gl_SYS_SOCKET_MODULE_INDICATOR' => 1, - 'gl_SYS_STAT_H' => 1, - 'gl_SYS_STAT_H_DEFAULTS' => 1, - 'gl_SYS_STAT_H_REQUIRE_DEFAULTS' => 1, - 'gl_SYS_STAT_MODULE_INDICATOR' => 1, - 'gl_SYS_TYPES_H' => 1, - 'gl_SYS_TYPES_H_DEFAULTS' => 1, - 'gl_SYS_TYPES_H_REQUIRE_DEFAULTS' => 1, - 'gl_THREADLIB' => 1, - 'gl_THREADLIB_BODY' => 1, - 'gl_THREADLIB_EARLY' => 1, - 'gl_THREADLIB_EARLY_BODY' => 1, - 'gl_TIME_H' => 1, - 'gl_TIME_H_DEFAULTS' => 1, - 'gl_TIME_H_REQUIRE_DEFAULTS' => 1, - 'gl_TIME_MODULE_INDICATOR' => 1, - 'gl_TYPE_CHAR16_T' => 1, - 'gl_TYPE_CHAR32_T' => 1, - 'gl_TYPE_CHAR8_T' => 1, - 'gl_TYPE_OFF_T' => 1, - 'gl_TYPE_WINT_T_PREREQ' => 1, - 'gl_UCHAR_H' => 1, - 'gl_UCHAR_H_DEFAULTS' => 1, - 'gl_UCHAR_H_REQUIRE_DEFAULTS' => 1, - 'gl_UCHAR_MODULE_INDICATOR' => 1, - 'gl_UNICASE_H' => 1, - 'gl_UNICASE_H_DEFAULTS' => 1, - 'gl_UNICASE_H_REQUIRE_DEFAULTS' => 1, - 'gl_UNICASE_MODULE_INDICATOR' => 1, - 'gl_UNICTYPE_H' => 1, - 'gl_UNICTYPE_H_DEFAULTS' => 1, - 'gl_UNICTYPE_H_REQUIRE_DEFAULTS' => 1, - 'gl_UNICTYPE_MODULE_INDICATOR' => 1, - 'gl_UNINORM_H' => 1, - 'gl_UNINORM_H_DEFAULTS' => 1, - 'gl_UNINORM_H_REQUIRE_DEFAULTS' => 1, - 'gl_UNINORM_MODULE_INDICATOR' => 1, - 'gl_UNISTD_H' => 1, - 'gl_UNISTD_H_DEFAULTS' => 1, - 'gl_UNISTD_H_REQUIRE_DEFAULTS' => 1, - 'gl_UNISTD_MODULE_INDICATOR' => 1, - 'gl_UNKNOWN_WARNINGS_ARE_ERRORS' => 1, - 'gl_UNKNOWN_WARNINGS_ARE_ERRORS(C)' => 1, - 'gl_UNKNOWN_WARNINGS_ARE_ERRORS(C++)' => 1, - 'gl_UNKNOWN_WARNINGS_ARE_ERRORS(Objective C)' => 1, - 'gl_UNKNOWN_WARNINGS_ARE_ERRORS_IMPL' => 1, - 'gl_USE_SYSTEM_EXTENSIONS' => 1, - 'gl_VISIBILITY' => 1, - 'gl_W' => 1, - 'gl_WARN_ADD' => 1, - 'gl_WARN_ON_USE_PREPARE' => 1, - 'gl_WCHAR_H' => 1, - 'gl_WCHAR_H_DEFAULTS' => 1, - 'gl_WCHAR_H_INLINE_OK' => 1, - 'gl_WCHAR_H_REQUIRE_DEFAULTS' => 1, - 'gl_WCHAR_MODULE_INDICATOR' => 1, - 'gl_WCTYPE_H' => 1, - 'gl_WCTYPE_H_DEFAULTS' => 1, - 'gl_WCTYPE_H_REQUIRE_DEFAULTS' => 1, - 'gl_WCTYPE_MODULE_INDICATOR' => 1, - 'gl_WEAK_SYMBOLS' => 1, - 'gl_WOE32_DLL' => 1, - 'gl_XALLOC' => 1, - 'gl_ZZGNULIB' => 1, - 'gl___BUILTIN_EXPECT' => 1, - 'gl___INLINE' => 1, - 'gltests_LIBOBJ' => 1, - 'gltests_LIBSOURCES' => 1, - 'gltests_REPLACE_FUNCS' => 1, - 'gt_CHECK_VAR_DECL' => 1, - 'gt_CSHARPCOMP' => 1, - 'gt_CSHARP_CHOICE' => 1, - 'gt_FUNC_USELOCALE' => 1, - 'gt_INTL_MACOSX' => 1, - 'gt_INTL_THREAD_LOCALE_NAME' => 1, - 'gt_JAVACOMP' => 1, - 'gt_JAVACOMP_DISABLED' => 1, - 'gt_JAVA_CHOICE' => 1, - 'gt_LC_MESSAGES' => 1, - 'gt_LOCALE_FR' => 1, - 'gt_LOCALE_FR_UTF8' => 1, - 'gt_LOCALE_JA' => 1, - 'gt_LOCALE_ZH_CN' => 1, - 'gt_MORE_WARNINGS' => 1, - 'gt_TYPE_SSIZE_T' => 1, - 'gt_TYPE_WCHAR_T' => 1, - 'gt_TYPE_WINT_T' => 1, - 'include' => 1, - 'm4_include' => 1, - 'm4_pattern_allow' => 1, - 'm4_pattern_forbid' => 1 - } - ], 'Autom4te::Request' ), - bless( [ - '1', - 1, - [ - '/usr/share/autoconf', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot//share/aclocal' - ], - [ - '/usr/share/autoconf/autoconf/autoconf.m4f', - 'aclocal.m4', - 'configure.ac' - ], - { - 'AC_CANONICAL_BUILD' => 1, - 'AC_CANONICAL_HOST' => 1, - 'AC_CANONICAL_SYSTEM' => 1, - 'AC_CANONICAL_TARGET' => 1, - 'AC_CONFIG_AUX_DIR' => 1, - 'AC_CONFIG_FILES' => 1, - 'AC_CONFIG_HEADERS' => 1, - 'AC_CONFIG_LIBOBJ_DIR' => 1, - 'AC_CONFIG_LINKS' => 1, - 'AC_CONFIG_MACRO_DIR_TRACE' => 1, - 'AC_CONFIG_SUBDIRS' => 1, - 'AC_DEFINE_TRACE_LITERAL' => 1, - 'AC_FC_FREEFORM' => 1, - 'AC_FC_PP_DEFINE' => 1, - 'AC_FC_PP_SRCEXT' => 1, - 'AC_FC_SRCEXT' => 1, - 'AC_INIT' => 1, - 'AC_LIBSOURCE' => 1, - 'AC_PROG_LIBTOOL' => 1, - 'AC_REQUIRE_AUX_FILE' => 1, - 'AC_SUBST' => 1, - 'AC_SUBST_TRACE' => 1, - 'AH_OUTPUT' => 1, - 'AM_AUTOMAKE_VERSION' => 1, - 'AM_CONDITIONAL' => 1, - 'AM_ENABLE_MULTILIB' => 1, - 'AM_EXTRA_RECURSIVE_TARGETS' => 1, - 'AM_GNU_GETTEXT' => 1, - 'AM_GNU_GETTEXT_INTL_SUBDIR' => 1, - 'AM_INIT_AUTOMAKE' => 1, - 'AM_MAINTAINER_MODE' => 1, - 'AM_MAKEFILE_INCLUDE' => 1, - 'AM_NLS' => 1, - 'AM_PATH_GUILE' => 1, - 'AM_POT_TOOLS' => 1, - 'AM_PROG_AR' => 1, - 'AM_PROG_CC_C_O' => 1, - 'AM_PROG_CXX_C_O' => 1, - 'AM_PROG_F77_C_O' => 1, - 'AM_PROG_FC_C_O' => 1, - 'AM_PROG_LIBTOOL' => 1, - 'AM_PROG_MKDIR_P' => 1, - 'AM_PROG_MOC' => 1, - 'AM_SILENT_RULES' => 1, - 'AM_XGETTEXT_OPTION' => 1, - 'GTK_DOC_CHECK' => 1, - 'IT_PROG_INTLTOOL' => 1, - 'LT_CONFIG_LTDL_DIR' => 1, - 'LT_INIT' => 1, - 'LT_SUPPORTED_TAG' => 1, - '_AM_COND_ELSE' => 1, - '_AM_COND_ENDIF' => 1, - '_AM_COND_IF' => 1, - '_AM_MAKEFILE_INCLUDE' => 1, - '_AM_SUBST_NOTMAKE' => 1, - '_LT_AC_TAGCONFIG' => 1, - '_m4_warn' => 1, - 'include' => 1, - 'm4_include' => 1, - 'm4_pattern_allow' => 1, - 'm4_pattern_forbid' => 1, - 'm4_sinclude' => 1, - 'sinclude' => 1 - } - ], 'Autom4te::Request' ), - bless( [ - '2', - 1, - [ - '/usr/share/autoconf', - '/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot//share/aclocal' - ], - [ - '/usr/share/autoconf/autoconf/autoconf.m4f', - 'aclocal.m4', - '/usr/share/autoconf/autoconf/trailer.m4', - 'configure.ac' - ], - { - 'AC_CANONICAL_BUILD' => 1, - 'AC_CANONICAL_HOST' => 1, - 'AC_CANONICAL_SYSTEM' => 1, - 'AC_CANONICAL_TARGET' => 1, - 'AC_CONFIG_AUX_DIR' => 1, - 'AC_CONFIG_FILES' => 1, - 'AC_CONFIG_HEADERS' => 1, - 'AC_CONFIG_LIBOBJ_DIR' => 1, - 'AC_CONFIG_LINKS' => 1, - 'AC_CONFIG_MACRO_DIR_TRACE' => 1, - 'AC_CONFIG_SUBDIRS' => 1, - 'AC_DEFINE_TRACE_LITERAL' => 1, - 'AC_FC_FREEFORM' => 1, - 'AC_FC_PP_DEFINE' => 1, - 'AC_FC_PP_SRCEXT' => 1, - 'AC_FC_SRCEXT' => 1, - 'AC_INIT' => 1, - 'AC_LIBSOURCE' => 1, - 'AC_PROG_LIBTOOL' => 1, - 'AC_REQUIRE_AUX_FILE' => 1, - 'AC_SUBST' => 1, - 'AC_SUBST_TRACE' => 1, - 'AH_OUTPUT' => 1, - 'AM_AUTOMAKE_VERSION' => 1, - 'AM_CONDITIONAL' => 1, - 'AM_ENABLE_MULTILIB' => 1, - 'AM_EXTRA_RECURSIVE_TARGETS' => 1, - 'AM_GNU_GETTEXT' => 1, - 'AM_GNU_GETTEXT_INTL_SUBDIR' => 1, - 'AM_INIT_AUTOMAKE' => 1, - 'AM_MAINTAINER_MODE' => 1, - 'AM_MAKEFILE_INCLUDE' => 1, - 'AM_NLS' => 1, - 'AM_PATH_GUILE' => 1, - 'AM_POT_TOOLS' => 1, - 'AM_PROG_AR' => 1, - 'AM_PROG_CC_C_O' => 1, - 'AM_PROG_CXX_C_O' => 1, - 'AM_PROG_F77_C_O' => 1, - 'AM_PROG_FC_C_O' => 1, - 'AM_PROG_LIBTOOL' => 1, - 'AM_PROG_MKDIR_P' => 1, - 'AM_PROG_MOC' => 1, - 'AM_SILENT_RULES' => 1, - 'AM_XGETTEXT_OPTION' => 1, - 'GTK_DOC_CHECK' => 1, - 'IT_PROG_INTLTOOL' => 1, - 'LT_CONFIG_LTDL_DIR' => 1, - 'LT_INIT' => 1, - 'LT_SUPPORTED_TAG' => 1, - '_AM_COND_ELSE' => 1, - '_AM_COND_ENDIF' => 1, - '_AM_COND_IF' => 1, - '_AM_MAKEFILE_INCLUDE' => 1, - '_AM_SUBST_NOTMAKE' => 1, - '_LT_AC_TAGCONFIG' => 1, - '_m4_warn' => 1, - 'include' => 1, - 'm4_include' => 1, - 'm4_pattern_allow' => 1, - 'm4_pattern_forbid' => 1, - 'm4_sinclude' => 1, - 'sinclude' => 1 - } - ], 'Autom4te::Request' ), - bless( [ - '3', - 1, - [ - '/usr/share/autoconf' - ], - [ - '/usr/share/autoconf/autoconf/autoconf.m4f', - 'aclocal.m4', - 'configure.ac' - ], - { - 'AC_ARG_ENABLE' => 1, - 'AC_ARG_VAR' => 1, - 'AC_ARG_WITH' => 1, - 'AC_CANONICAL_BUILD' => 1, - 'AC_CANONICAL_HOST' => 1, - 'AC_CANONICAL_SYSTEM' => 1, - 'AC_CANONICAL_TARGET' => 1, - 'AC_CONFIG_AUX_DIR' => 1, - 'AC_CONFIG_FILES' => 1, - 'AC_CONFIG_HEADERS' => 1, - 'AC_CONFIG_LIBOBJ_DIR' => 1, - 'AC_CONFIG_LINKS' => 1, - 'AC_CONFIG_MACRO_DIR_TRACE' => 1, - 'AC_CONFIG_SUBDIRS' => 1, - 'AC_DEFINE_TRACE_LITERAL' => 1, - 'AC_FC_FREEFORM' => 1, - 'AC_FC_PP_DEFINE' => 1, - 'AC_FC_PP_SRCEXT' => 1, - 'AC_FC_SRCEXT' => 1, - 'AC_INIT' => 1, - 'AC_LIBSOURCE' => 1, - 'AC_PROG_LIBTOOL' => 1, - 'AC_REQUIRE_AUX_FILE' => 1, - 'AC_SUBST' => 1, - 'AC_SUBST_TRACE' => 1, - 'AH_OUTPUT' => 1, - 'AM_AUTOMAKE_VERSION' => 1, - 'AM_CONDITIONAL' => 1, - 'AM_ENABLE_MULTILIB' => 1, - 'AM_EXTRA_RECURSIVE_TARGETS' => 1, - 'AM_GNU_GETTEXT' => 1, - 'AM_GNU_GETTEXT_INTL_SUBDIR' => 1, 'AM_INIT_AUTOMAKE' => 1, 'AM_MAINTAINER_MODE' => 1, 'AM_MAKEFILE_INCLUDE' => 1, @@ -1022,6 +68,7 @@ 'AM_SILENT_RULES' => 1, 'AM_XGETTEXT_OPTION' => 1, 'GTK_DOC_CHECK' => 1, + 'GUILE_FLAGS' => 1, 'IT_PROG_INTLTOOL' => 1, 'LT_CONFIG_LTDL_DIR' => 1, 'LT_INIT' => 1, diff --git a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/traces.0 b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/traces.0 index eecfad3969..9b1e83d85f 100644 --- a/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/traces.0 +++ b/recipes/tools/gettext/source/gettext-runtime/autom4te.cache/traces.0 @@ -1,3031 +1,1157 @@ -m4trace:/usr/share/aclocal-1.18/amversion.m4:14: -1- AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version='1.18' -dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to -dnl require some minimum version. Point them to the right macro. -m4_if([$1], [1.18.1], [], - [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl -]) -m4trace:/usr/share/aclocal-1.18/amversion.m4:33: -1- AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], [AM_AUTOMAKE_VERSION([1.18.1])dnl -m4_ifndef([AC_AUTOCONF_VERSION], - [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl -_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) -m4trace:/usr/share/aclocal-1.18/auxdir.m4:47: -1- AC_DEFUN([AM_AUX_DIR_EXPAND], [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl -# Expand $ac_aux_dir to an absolute path. -am_aux_dir=`cd "$ac_aux_dir" && pwd` -]) -m4trace:/usr/share/aclocal-1.18/cond-if.m4:23: -1- AC_DEFUN([AM_COND_IF], [m4_ifndef([_AM_COND_VALUE_$1], - [m4_fatal([$0: no such condition "$1"])])dnl -_AM_COND_IF([$1])dnl -if test -z "$$1_TRUE"; then : - m4_n([$2])[]dnl -m4_ifval([$3], -[_AM_COND_ELSE([$1])dnl -else - $3 -])dnl -_AM_COND_ENDIF([$1])dnl -fi[]dnl -]) -m4trace:/usr/share/aclocal-1.18/cond.m4:12: -1- AC_DEFUN([AM_CONDITIONAL], [AC_PREREQ([2.52])dnl - m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], - [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl -AC_SUBST([$1_TRUE])dnl -AC_SUBST([$1_FALSE])dnl -_AM_SUBST_NOTMAKE([$1_TRUE])dnl -_AM_SUBST_NOTMAKE([$1_FALSE])dnl -m4_define([_AM_COND_VALUE_$1], [$2])dnl -if $2; then - $1_TRUE= - $1_FALSE='#' -else - $1_TRUE='#' - $1_FALSE= -fi -AC_CONFIG_COMMANDS_PRE( -[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then - AC_MSG_ERROR([[conditional "$1" was never defined. -Usually this means the macro was only invoked conditionally.]]) -fi])]) -m4trace:/usr/share/aclocal-1.18/depend.m4:26: -1- AC_DEFUN([_AM_DEPENDENCIES], [AC_REQUIRE([AM_SET_DEPDIR])dnl -AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl -AC_REQUIRE([AM_MAKE_INCLUDE])dnl -AC_REQUIRE([AM_DEP_TRACK])dnl - -m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], - [$1], [CXX], [depcc="$CXX" am_compiler_list=], - [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], - [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], - [$1], [UPC], [depcc="$UPC" am_compiler_list=], - [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], - [depcc="$$1" am_compiler_list=]) - -AC_CACHE_CHECK([dependency style of $depcc], - [am_cv_$1_dependencies_compiler_type], -[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then - # We make a subdir and do the tests there. Otherwise we can end up - # making bogus files that we don't know about and never remove. For - # instance it was reported that on HP-UX the gcc test will end up - # making a dummy file named 'D' -- because '-MD' means "put the output - # in D". - rm -rf conftest.dir - mkdir conftest.dir - # Copy depcomp to subdir because otherwise we won't find it if we're - # using a relative directory. - cp "$am_depcomp" conftest.dir - cd conftest.dir - # We will build objects and dependencies in a subdirectory because - # it helps to detect inapplicable dependency modes. For instance - # both Tru64's cc and ICC support -MD to output dependencies as a - # side effect of compilation, but ICC will put the dependencies in - # the current directory while Tru64 will put them in the object - # directory. - mkdir sub - - am_cv_$1_dependencies_compiler_type=none - if test "$am_compiler_list" = ""; then - am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` - fi - am__universal=false - m4_case([$1], [CC], - [case " $depcc " in #( - *\ -arch\ *\ -arch\ *) am__universal=true ;; - esac], - [CXX], - [case " $depcc " in #( - *\ -arch\ *\ -arch\ *) am__universal=true ;; - esac]) - - for depmode in $am_compiler_list; do - # Setup a source with many dependencies, because some compilers - # like to wrap large dependency lists on column 80 (with \), and - # we should not choose a depcomp mode which is confused by this. - # - # We need to recreate these files for each test, as the compiler may - # overwrite some of them when testing with obscure command lines. - # This happens at least with the AIX C compiler. - : > sub/conftest.c - for i in 1 2 3 4 5 6; do - echo '#include "conftst'$i'.h"' >> sub/conftest.c - # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with - # Solaris 10 /bin/sh. - echo '/* dummy */' > sub/conftst$i.h - done - echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf - - # We check with '-c' and '-o' for the sake of the "dashmstdout" - # mode. It turns out that the SunPro C++ compiler does not properly - # handle '-M -o', and we need to detect this. Also, some Intel - # versions had trouble with output in subdirs. - am__obj=sub/conftest.${OBJEXT-o} - am__minus_obj="-o $am__obj" - case $depmode in - gcc) - # This depmode causes a compiler race in universal mode. - test "$am__universal" = false || continue - ;; - nosideeffect) - # After this tag, mechanisms are not by side-effect, so they'll - # only be used when explicitly requested. - if test "x$enable_dependency_tracking" = xyes; then - continue - else - break - fi - ;; - msvc7 | msvc7msys | msvisualcpp | msvcmsys) - # This compiler won't grok '-c -o', but also, the minuso test has - # not run yet. These depmodes are late enough in the game, and - # so weak that their functioning should not be impacted. - am__obj=conftest.${OBJEXT-o} - am__minus_obj= - ;; - none) break ;; - esac - if depmode=$depmode \ - source=sub/conftest.c object=$am__obj \ - depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ - $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ - >/dev/null 2>conftest.err && - grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && - grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && - grep $am__obj sub/conftest.Po > /dev/null 2>&1 && - ${MAKE-make} -s -f confmf > /dev/null 2>&1; then - # icc doesn't choke on unknown options, it will just issue warnings - # or remarks (even with -Werror). So we grep stderr for any message - # that says an option was ignored or not supported. - # When given -MP, icc 7.0 and 7.1 complain thus: - # icc: Command line warning: ignoring option '-M'; no argument required - # The diagnosis changed in icc 8.0: - # icc: Command line remark: option '-MP' not supported - if (grep 'ignoring option' conftest.err || - grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else - am_cv_$1_dependencies_compiler_type=$depmode - break - fi - fi - done - - cd .. - rm -rf conftest.dir -else - am_cv_$1_dependencies_compiler_type=none -fi -]) -AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) -AM_CONDITIONAL([am__fastdep$1], [ +m4trace:aclocal.m4:699: -1- AC_SUBST([am__quote]) +m4trace:aclocal.m4:699: -1- AC_SUBST_TRACE([am__quote]) +m4trace:aclocal.m4:699: -1- m4_pattern_allow([^am__quote$]) +m4trace:aclocal.m4:1355: -1- m4_include([gnulib-m4/00gnulib.m4]) +m4trace:aclocal.m4:1356: -1- m4_include([gnulib-m4/__inline.m4]) +m4trace:aclocal.m4:1357: -1- m4_include([gnulib-m4/absolute-header.m4]) +m4trace:aclocal.m4:1358: -1- m4_include([gnulib-m4/alloca.m4]) +m4trace:aclocal.m4:1359: -1- m4_include([gnulib-m4/ansi-c++.m4]) +m4trace:aclocal.m4:1360: -1- m4_include([gnulib-m4/asm-underscore.m4]) +m4trace:aclocal.m4:1361: -1- m4_include([gnulib-m4/assert_h.m4]) +m4trace:aclocal.m4:1362: -1- m4_include([gnulib-m4/atexit.m4]) +m4trace:aclocal.m4:1363: -1- m4_include([gnulib-m4/builtin-expect.m4]) +m4trace:aclocal.m4:1364: -1- m4_include([gnulib-m4/c-bool.m4]) +m4trace:aclocal.m4:1365: -1- m4_include([gnulib-m4/calloc.m4]) +m4trace:aclocal.m4:1366: -1- m4_include([gnulib-m4/canonicalize.m4]) +m4trace:aclocal.m4:1367: -1- m4_include([gnulib-m4/close.m4]) +m4trace:aclocal.m4:1368: -1- m4_include([gnulib-m4/codeset.m4]) +m4trace:aclocal.m4:1369: -1- m4_include([gnulib-m4/csharp.m4]) +m4trace:aclocal.m4:1370: -1- m4_include([gnulib-m4/csharpcomp.m4]) +m4trace:aclocal.m4:1371: -1- m4_include([gnulib-m4/double-slash-root.m4]) +m4trace:aclocal.m4:1372: -1- m4_include([gnulib-m4/dup2.m4]) +m4trace:aclocal.m4:1373: -1- m4_include([gnulib-m4/eealloc.m4]) +m4trace:aclocal.m4:1374: -1- m4_include([gnulib-m4/environ.m4]) +m4trace:aclocal.m4:1375: -1- m4_include([gnulib-m4/errno_h.m4]) +m4trace:aclocal.m4:1376: -1- m4_include([gnulib-m4/error.m4]) +m4trace:aclocal.m4:1377: -1- m4_include([gnulib-m4/error_h.m4]) +m4trace:aclocal.m4:1378: -1- m4_include([gnulib-m4/extensions.m4]) +m4trace:aclocal.m4:1379: -1- m4_include([gnulib-m4/extern-inline.m4]) +m4trace:aclocal.m4:1380: -1- m4_include([gnulib-m4/fcntl.m4]) +m4trace:aclocal.m4:1381: -1- m4_include([gnulib-m4/fcntl_h.m4]) +m4trace:aclocal.m4:1382: -1- m4_include([gnulib-m4/free.m4]) +m4trace:aclocal.m4:1383: -1- m4_include([gnulib-m4/fstat.m4]) +m4trace:aclocal.m4:1384: -1- m4_include([gnulib-m4/getdtablesize.m4]) +m4trace:aclocal.m4:1385: -1- m4_include([gnulib-m4/getopt.m4]) +m4trace:aclocal.m4:1386: -1- m4_include([gnulib-m4/getprogname.m4]) +m4trace:aclocal.m4:1387: -1- m4_include([gnulib-m4/gnulib-common.m4]) +m4trace:aclocal.m4:1388: -1- m4_include([gnulib-m4/gnulib-comp.m4]) +m4trace:aclocal.m4:1389: -1- m4_include([gnulib-m4/host-cpu-c-abi.m4]) +m4trace:aclocal.m4:1390: -1- m4_include([gnulib-m4/iconv_h.m4]) +m4trace:aclocal.m4:1391: -1- m4_include([gnulib-m4/iconv_open.m4]) +m4trace:aclocal.m4:1392: -1- m4_include([gnulib-m4/include_next.m4]) +m4trace:aclocal.m4:1393: -1- m4_include([gnulib-m4/inline.m4]) +m4trace:aclocal.m4:1394: -1- m4_include([gnulib-m4/intl-thread-locale.m4]) +m4trace:aclocal.m4:1395: -1- m4_include([gnulib-m4/inttypes.m4]) +m4trace:aclocal.m4:1396: -1- m4_include([gnulib-m4/iswblank.m4]) +m4trace:aclocal.m4:1397: -1- m4_include([gnulib-m4/iswdigit.m4]) +m4trace:aclocal.m4:1398: -1- m4_include([gnulib-m4/iswpunct.m4]) +m4trace:aclocal.m4:1399: -1- m4_include([gnulib-m4/iswxdigit.m4]) +m4trace:aclocal.m4:1400: -1- m4_include([gnulib-m4/java.m4]) +m4trace:aclocal.m4:1401: -1- m4_include([gnulib-m4/javacomp.m4]) +m4trace:aclocal.m4:1402: -1- m4_include([gnulib-m4/langinfo_h.m4]) +m4trace:aclocal.m4:1403: -1- m4_include([gnulib-m4/largefile.m4]) +m4trace:aclocal.m4:1404: -1- m4_include([gnulib-m4/lcmessage.m4]) +m4trace:aclocal.m4:1405: -1- m4_include([gnulib-m4/lib-ld.m4]) +m4trace:aclocal.m4:1406: -1- m4_include([gnulib-m4/lib-link.m4]) +m4trace:aclocal.m4:1407: -1- m4_include([gnulib-m4/lib-prefix.m4]) +m4trace:aclocal.m4:1408: -1- m4_include([gnulib-m4/libunistring-base.m4]) +m4trace:aclocal.m4:1409: -1- m4_include([gnulib-m4/limits-h.m4]) +m4trace:aclocal.m4:1410: -1- m4_include([gnulib-m4/localcharset.m4]) +m4trace:aclocal.m4:1411: -1- m4_include([gnulib-m4/locale-fr.m4]) +m4trace:aclocal.m4:1412: -1- m4_include([gnulib-m4/locale-ja.m4]) +m4trace:aclocal.m4:1413: -1- m4_include([gnulib-m4/locale-zh.m4]) +m4trace:aclocal.m4:1414: -1- m4_include([gnulib-m4/locale_h.m4]) +m4trace:aclocal.m4:1415: -1- m4_include([gnulib-m4/localename.m4]) +m4trace:aclocal.m4:1416: -1- m4_include([gnulib-m4/lock.m4]) +m4trace:aclocal.m4:1417: -1- m4_include([gnulib-m4/lstat.m4]) +m4trace:aclocal.m4:1418: -1- m4_include([gnulib-m4/malloc.m4]) +m4trace:aclocal.m4:1419: -1- m4_include([gnulib-m4/malloca.m4]) +m4trace:aclocal.m4:1420: -1- m4_include([gnulib-m4/manywarnings.m4]) +m4trace:aclocal.m4:1421: -1- m4_include([gnulib-m4/mbchar.m4]) +m4trace:aclocal.m4:1422: -1- m4_include([gnulib-m4/mbiter.m4]) +m4trace:aclocal.m4:1423: -1- m4_include([gnulib-m4/mbrtoc32.m4]) +m4trace:aclocal.m4:1424: -1- m4_include([gnulib-m4/mbrtowc.m4]) +m4trace:aclocal.m4:1425: -1- m4_include([gnulib-m4/mbsinit.m4]) +m4trace:aclocal.m4:1426: -1- m4_include([gnulib-m4/mbslen.m4]) +m4trace:aclocal.m4:1427: -1- m4_include([gnulib-m4/mbstate_t.m4]) +m4trace:aclocal.m4:1428: -1- m4_include([gnulib-m4/memchr.m4]) +m4trace:aclocal.m4:1429: -1- m4_include([gnulib-m4/memmove.m4]) +m4trace:aclocal.m4:1430: -1- m4_include([gnulib-m4/mempcpy.m4]) +m4trace:aclocal.m4:1431: -1- m4_include([gnulib-m4/minmax.m4]) +m4trace:aclocal.m4:1432: -1- m4_include([gnulib-m4/mmap-anon.m4]) +m4trace:aclocal.m4:1433: -1- m4_include([gnulib-m4/mode_t.m4]) +m4trace:aclocal.m4:1434: -1- m4_include([gnulib-m4/msvc-inval.m4]) +m4trace:aclocal.m4:1435: -1- m4_include([gnulib-m4/msvc-nothrow.m4]) +m4trace:aclocal.m4:1436: -1- m4_include([gnulib-m4/multiarch.m4]) +m4trace:aclocal.m4:1437: -1- m4_include([gnulib-m4/musl.m4]) +m4trace:aclocal.m4:1438: -1- m4_include([gnulib-m4/nocrash.m4]) +m4trace:aclocal.m4:1439: -1- m4_include([gnulib-m4/off_t.m4]) +m4trace:aclocal.m4:1440: -1- m4_include([gnulib-m4/open-cloexec.m4]) +m4trace:aclocal.m4:1441: -1- m4_include([gnulib-m4/open-slash.m4]) +m4trace:aclocal.m4:1442: -1- m4_include([gnulib-m4/open.m4]) +m4trace:aclocal.m4:1443: -1- m4_include([gnulib-m4/pathmax.m4]) +m4trace:aclocal.m4:1444: -1- m4_include([gnulib-m4/pthread_rwlock_rdlock.m4]) +m4trace:aclocal.m4:1445: -1- m4_include([gnulib-m4/raise.m4]) +m4trace:aclocal.m4:1446: -1- m4_include([gnulib-m4/rawmemchr.m4]) +m4trace:aclocal.m4:1447: -1- m4_include([gnulib-m4/readlink.m4]) +m4trace:aclocal.m4:1448: -1- m4_include([gnulib-m4/realloc.m4]) +m4trace:aclocal.m4:1449: -1- m4_include([gnulib-m4/reallocarray.m4]) +m4trace:aclocal.m4:1450: -1- m4_include([gnulib-m4/relocatable-lib.m4]) +m4trace:aclocal.m4:1451: -1- m4_include([gnulib-m4/relocatable.m4]) +m4trace:aclocal.m4:1452: -1- m4_include([gnulib-m4/setenv.m4]) +m4trace:aclocal.m4:1453: -1- m4_include([gnulib-m4/setlocale.m4]) +m4trace:aclocal.m4:1454: -1- m4_include([gnulib-m4/setlocale_null.m4]) +m4trace:aclocal.m4:1455: -1- m4_include([gnulib-m4/signal_h.m4]) +m4trace:aclocal.m4:1456: -1- m4_include([gnulib-m4/signalblocking.m4]) +m4trace:aclocal.m4:1457: -1- m4_include([gnulib-m4/sigpipe.m4]) +m4trace:aclocal.m4:1458: -1- m4_include([gnulib-m4/ssize_t.m4]) +m4trace:aclocal.m4:1459: -1- m4_include([gnulib-m4/stat-time.m4]) +m4trace:aclocal.m4:1460: -1- m4_include([gnulib-m4/stat.m4]) +m4trace:aclocal.m4:1461: -1- m4_include([gnulib-m4/stdalign.m4]) +m4trace:aclocal.m4:1462: -1- m4_include([gnulib-m4/stddef_h.m4]) +m4trace:aclocal.m4:1463: -1- m4_include([gnulib-m4/stdint.m4]) +m4trace:aclocal.m4:1464: -1- m4_include([gnulib-m4/stdio_h.m4]) +m4trace:aclocal.m4:1465: -1- m4_include([gnulib-m4/stdlib_h.m4]) +m4trace:aclocal.m4:1466: -1- m4_include([gnulib-m4/strerror.m4]) +m4trace:aclocal.m4:1467: -1- m4_include([gnulib-m4/string_h.m4]) +m4trace:aclocal.m4:1468: -1- m4_include([gnulib-m4/strnlen.m4]) +m4trace:aclocal.m4:1469: -1- m4_include([gnulib-m4/strtoul.m4]) +m4trace:aclocal.m4:1470: -1- m4_include([gnulib-m4/sys_socket_h.m4]) +m4trace:aclocal.m4:1471: -1- m4_include([gnulib-m4/sys_stat_h.m4]) +m4trace:aclocal.m4:1472: -1- m4_include([gnulib-m4/sys_types_h.m4]) +m4trace:aclocal.m4:1473: -1- m4_include([gnulib-m4/threadlib.m4]) +m4trace:aclocal.m4:1474: -1- m4_include([gnulib-m4/time_h.m4]) +m4trace:aclocal.m4:1475: -1- m4_include([gnulib-m4/uchar_h.m4]) +m4trace:aclocal.m4:1476: -1- m4_include([gnulib-m4/unicase_h.m4]) +m4trace:aclocal.m4:1477: -1- m4_include([gnulib-m4/unictype_h.m4]) +m4trace:aclocal.m4:1478: -1- m4_include([gnulib-m4/uninorm_h.m4]) +m4trace:aclocal.m4:1479: -1- m4_include([gnulib-m4/unistd_h.m4]) +m4trace:aclocal.m4:1480: -1- m4_include([gnulib-m4/unlocked-io.m4]) +m4trace:aclocal.m4:1481: -1- m4_include([gnulib-m4/warn-on-use.m4]) +m4trace:aclocal.m4:1482: -1- m4_include([gnulib-m4/warnings.m4]) +m4trace:aclocal.m4:1483: -1- m4_include([gnulib-m4/wchar_h.m4]) +m4trace:aclocal.m4:1484: -1- m4_include([gnulib-m4/wchar_t.m4]) +m4trace:aclocal.m4:1485: -1- m4_include([gnulib-m4/wctype_h.m4]) +m4trace:aclocal.m4:1486: -1- m4_include([gnulib-m4/wcwidth.m4]) +m4trace:aclocal.m4:1487: -1- m4_include([gnulib-m4/wint_t.m4]) +m4trace:aclocal.m4:1488: -1- m4_include([gnulib-m4/xalloc.m4]) +m4trace:aclocal.m4:1489: -1- m4_include([gnulib-m4/zzgnulib.m4]) +m4trace:aclocal.m4:1490: -1- m4_include([../m4/fixautomake.m4]) +m4trace:aclocal.m4:1491: -1- m4_include([../m4/more-warnings.m4]) +m4trace:aclocal.m4:1492: -1- m4_include([../m4/woe32-dll.m4]) +m4trace:aclocal.m4:1493: -1- m4_include([m4/build-to-host.m4]) +m4trace:aclocal.m4:1494: -1- m4_include([m4/fcntl-o.m4]) +m4trace:aclocal.m4:1495: -1- m4_include([m4/flexmember.m4]) +m4trace:aclocal.m4:1496: -1- m4_include([m4/gettext.m4]) +m4trace:aclocal.m4:1497: -1- m4_include([m4/iconv.m4]) +m4trace:aclocal.m4:1498: -1- m4_include([m4/intlmacosx.m4]) +m4trace:aclocal.m4:1499: -1- m4_include([m4/nls.m4]) +m4trace:aclocal.m4:1500: -1- m4_include([m4/po.m4]) +m4trace:aclocal.m4:1501: -1- m4_include([m4/progtest.m4]) +m4trace:aclocal.m4:1502: -1- m4_include([m4/visibility.m4]) +m4trace:configure.ac:20: -1- AC_INIT([gettext-runtime], [0.22.5], [bug-gettext@gnu.org]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?A[CHUM]_]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([_AC_]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section 'AC_LIBOBJ vs LIBOBJS']) +m4trace:configure.ac:20: -1- m4_pattern_allow([^AS_FLAGS$]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?m4_]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([^dnl$]) +m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?AS_]) +m4trace:configure.ac:20: -1- AC_SUBST([SHELL]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([SHELL]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^SHELL$]) +m4trace:configure.ac:20: -1- AC_SUBST([PATH_SEPARATOR]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PATH_SEPARATOR]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PATH_SEPARATOR$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_NAME], [m4_ifdef([AC_PACKAGE_NAME], ['AC_PACKAGE_NAME'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_NAME]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_NAME$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_TARNAME], [m4_ifdef([AC_PACKAGE_TARNAME], ['AC_PACKAGE_TARNAME'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_TARNAME]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_VERSION], [m4_ifdef([AC_PACKAGE_VERSION], ['AC_PACKAGE_VERSION'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_VERSION]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_VERSION$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_STRING], [m4_ifdef([AC_PACKAGE_STRING], ['AC_PACKAGE_STRING'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_STRING]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_STRING$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_BUGREPORT], [m4_ifdef([AC_PACKAGE_BUGREPORT], ['AC_PACKAGE_BUGREPORT'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_BUGREPORT]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) +m4trace:configure.ac:20: -1- AC_SUBST([PACKAGE_URL], [m4_ifdef([AC_PACKAGE_URL], ['AC_PACKAGE_URL'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([PACKAGE_URL]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_URL$]) +m4trace:configure.ac:20: -1- AC_SUBST([exec_prefix], [NONE]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([exec_prefix]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^exec_prefix$]) +m4trace:configure.ac:20: -1- AC_SUBST([prefix], [NONE]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([prefix]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^prefix$]) +m4trace:configure.ac:20: -1- AC_SUBST([program_transform_name], [s,x,x,]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([program_transform_name]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^program_transform_name$]) +m4trace:configure.ac:20: -1- AC_SUBST([bindir], ['${exec_prefix}/bin']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([bindir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^bindir$]) +m4trace:configure.ac:20: -1- AC_SUBST([sbindir], ['${exec_prefix}/sbin']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([sbindir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^sbindir$]) +m4trace:configure.ac:20: -1- AC_SUBST([libexecdir], ['${exec_prefix}/libexec']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([libexecdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^libexecdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([datarootdir], ['${prefix}/share']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([datarootdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^datarootdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([datadir], ['${datarootdir}']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([datadir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^datadir$]) +m4trace:configure.ac:20: -1- AC_SUBST([sysconfdir], ['${prefix}/etc']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([sysconfdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^sysconfdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([sharedstatedir], ['${prefix}/com']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([sharedstatedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^sharedstatedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([localstatedir], ['${prefix}/var']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([localstatedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^localstatedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([runstatedir], ['${localstatedir}/run']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([runstatedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^runstatedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([includedir], ['${prefix}/include']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([includedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^includedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([oldincludedir], ['/usr/include']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([oldincludedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^oldincludedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([docdir], [m4_ifset([AC_PACKAGE_TARNAME], + ['${datarootdir}/doc/${PACKAGE_TARNAME}'], + ['${datarootdir}/doc/${PACKAGE}'])]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([docdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^docdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([infodir], ['${datarootdir}/info']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([infodir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^infodir$]) +m4trace:configure.ac:20: -1- AC_SUBST([htmldir], ['${docdir}']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([htmldir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^htmldir$]) +m4trace:configure.ac:20: -1- AC_SUBST([dvidir], ['${docdir}']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([dvidir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^dvidir$]) +m4trace:configure.ac:20: -1- AC_SUBST([pdfdir], ['${docdir}']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([pdfdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^pdfdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([psdir], ['${docdir}']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([psdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^psdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([libdir], ['${exec_prefix}/lib']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([libdir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^libdir$]) +m4trace:configure.ac:20: -1- AC_SUBST([localedir], ['${datarootdir}/locale']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([localedir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^localedir$]) +m4trace:configure.ac:20: -1- AC_SUBST([mandir], ['${datarootdir}/man']) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([mandir]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^mandir$]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_NAME]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_NAME$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_NAME], [/* Define to the full name of this package. */ +@%:@undef PACKAGE_NAME]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_TARNAME]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_TARNAME], [/* Define to the one symbol short name of this package. */ +@%:@undef PACKAGE_TARNAME]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_VERSION]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_VERSION$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_VERSION], [/* Define to the version of this package. */ +@%:@undef PACKAGE_VERSION]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_STRING]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_STRING$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_STRING], [/* Define to the full name and version of this package. */ +@%:@undef PACKAGE_STRING]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_BUGREPORT]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_BUGREPORT], [/* Define to the address where bug reports for this package should be sent. */ +@%:@undef PACKAGE_BUGREPORT]) +m4trace:configure.ac:20: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE_URL]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_URL$]) +m4trace:configure.ac:20: -1- AH_OUTPUT([PACKAGE_URL], [/* Define to the home page for this package. */ +@%:@undef PACKAGE_URL]) +m4trace:configure.ac:20: -1- AC_SUBST([DEFS]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([DEFS]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^DEFS$]) +m4trace:configure.ac:20: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:20: -1- AC_SUBST([build_alias]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([build_alias]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^build_alias$]) +m4trace:configure.ac:20: -1- AC_SUBST([host_alias]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([host_alias]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^host_alias$]) +m4trace:configure.ac:20: -1- AC_SUBST([target_alias]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([target_alias]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^target_alias$]) +m4trace:configure.ac:20: -1- AC_SUBST([ECHO_C]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([ECHO_C]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_C$]) +m4trace:configure.ac:20: -1- AC_SUBST([ECHO_N]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([ECHO_N]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_N$]) +m4trace:configure.ac:20: -1- AC_SUBST([ECHO_T]) +m4trace:configure.ac:20: -1- AC_SUBST_TRACE([ECHO_T]) +m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_T$]) +m4trace:configure.ac:24: -1- AC_CONFIG_AUX_DIR([../build-aux]) +m4trace:configure.ac:25: -1- AM_INIT_AUTOMAKE([1.11.1 silent-rules parallel-tests]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_[A-Z]+FLAGS$]) +m4trace:configure.ac:25: -1- AM_AUTOMAKE_VERSION([1.18.1]) +m4trace:configure.ac:25: -1- AC_REQUIRE_AUX_FILE([install-sh]) +m4trace:configure.ac:25: -1- AC_SUBST([INSTALL_PROGRAM]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([INSTALL_PROGRAM]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_PROGRAM$]) +m4trace:configure.ac:25: -1- AC_SUBST([INSTALL_SCRIPT]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([INSTALL_SCRIPT]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_SCRIPT$]) +m4trace:configure.ac:25: -1- AC_SUBST([INSTALL_DATA]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([INSTALL_DATA]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_DATA$]) +m4trace:configure.ac:25: -1- AC_SUBST([am__isrc], [' -I$(srcdir)']) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__isrc]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__isrc$]) +m4trace:configure.ac:25: -1- _AM_SUBST_NOTMAKE([am__isrc]) +m4trace:configure.ac:25: -1- AC_SUBST([CYGPATH_W]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([CYGPATH_W]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^CYGPATH_W$]) +m4trace:configure.ac:25: -1- AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME']) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([PACKAGE]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^PACKAGE$]) +m4trace:configure.ac:25: -1- AC_SUBST([VERSION], ['AC_PACKAGE_VERSION']) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([VERSION]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^VERSION$]) +m4trace:configure.ac:25: -1- AC_DEFINE_TRACE_LITERAL([PACKAGE]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^PACKAGE$]) +m4trace:configure.ac:25: -1- AH_OUTPUT([PACKAGE], [/* Name of package */ +@%:@undef PACKAGE]) +m4trace:configure.ac:25: -1- AC_DEFINE_TRACE_LITERAL([VERSION]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^VERSION$]) +m4trace:configure.ac:25: -1- AH_OUTPUT([VERSION], [/* Version number of package */ +@%:@undef VERSION]) +m4trace:configure.ac:25: -1- AC_REQUIRE_AUX_FILE([missing]) +m4trace:configure.ac:25: -1- AC_SUBST([ACLOCAL]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([ACLOCAL]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^ACLOCAL$]) +m4trace:configure.ac:25: -1- AC_SUBST([AUTOCONF]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AUTOCONF]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOCONF$]) +m4trace:configure.ac:25: -1- AC_SUBST([AUTOMAKE]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AUTOMAKE]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOMAKE$]) +m4trace:configure.ac:25: -1- AC_SUBST([AUTOHEADER]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AUTOHEADER]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOHEADER$]) +m4trace:configure.ac:25: -1- AC_SUBST([MAKEINFO]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([MAKEINFO]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^MAKEINFO$]) +m4trace:configure.ac:25: -1- AC_SUBST([install_sh]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([install_sh]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^install_sh$]) +m4trace:configure.ac:25: -1- AC_SUBST([STRIP]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([STRIP]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^STRIP$]) +m4trace:configure.ac:25: -1- AC_SUBST([INSTALL_STRIP_PROGRAM]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([INSTALL_STRIP_PROGRAM]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_STRIP_PROGRAM$]) +m4trace:configure.ac:25: -1- AC_REQUIRE_AUX_FILE([install-sh]) +m4trace:configure.ac:25: -1- AC_SUBST([MKDIR_P]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([MKDIR_P]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^MKDIR_P$]) +m4trace:configure.ac:25: -1- AC_SUBST([mkdir_p], ['$(MKDIR_P)']) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([mkdir_p]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^mkdir_p$]) +m4trace:configure.ac:25: -1- AC_SUBST([AWK]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AWK]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AWK$]) +m4trace:configure.ac:25: -1- AC_SUBST([SET_MAKE]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([SET_MAKE]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^SET_MAKE$]) +m4trace:configure.ac:25: -1- AC_SUBST([am__leading_dot]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__leading_dot]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__leading_dot$]) +m4trace:configure.ac:25: -1- AC_SUBST([AMTAR], ['$${TAR-tar}']) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AMTAR]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AMTAR$]) +m4trace:configure.ac:25: -1- AC_SUBST([am__tar]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__tar]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__tar$]) +m4trace:configure.ac:25: -1- AC_SUBST([am__untar]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__untar]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__untar$]) +m4trace:configure.ac:25: -1- AC_SUBST([CTAGS]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([CTAGS]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^CTAGS$]) +m4trace:configure.ac:25: -1- AC_SUBST([ETAGS]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([ETAGS]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^ETAGS$]) +m4trace:configure.ac:25: -1- AC_SUBST([CSCOPE]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([CSCOPE]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^CSCOPE$]) +m4trace:configure.ac:25: -1- AC_SUBST([AM_V]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AM_V]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_V$]) +m4trace:configure.ac:25: -1- _AM_SUBST_NOTMAKE([AM_V]) +m4trace:configure.ac:25: -1- AC_SUBST([AM_DEFAULT_V]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AM_DEFAULT_V]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_DEFAULT_V$]) +m4trace:configure.ac:25: -1- _AM_SUBST_NOTMAKE([AM_DEFAULT_V]) +m4trace:configure.ac:25: -1- AC_SUBST([AM_DEFAULT_VERBOSITY]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AM_DEFAULT_VERBOSITY]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_DEFAULT_VERBOSITY$]) +m4trace:configure.ac:25: -1- AC_SUBST([AM_BACKSLASH]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([AM_BACKSLASH]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_BACKSLASH$]) +m4trace:configure.ac:25: -1- _AM_SUBST_NOTMAKE([AM_BACKSLASH]) +m4trace:configure.ac:25: -1- AC_SUBST([am__rm_f_notfound]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__rm_f_notfound]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__rm_f_notfound$]) +m4trace:configure.ac:25: -1- AC_SUBST([am__xargs_n]) +m4trace:configure.ac:25: -1- AC_SUBST_TRACE([am__xargs_n]) +m4trace:configure.ac:25: -1- m4_pattern_allow([^am__xargs_n$]) +m4trace:configure.ac:26: -1- AC_CONFIG_HEADERS([config.h]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([CFLAGS]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CFLAGS]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CFLAGS$]) +m4trace:configure.ac:32: -1- AC_SUBST([LDFLAGS]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([LDFLAGS]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^LDFLAGS$]) +m4trace:configure.ac:32: -1- AC_SUBST([LIBS]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([LIBS]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^LIBS$]) +m4trace:configure.ac:32: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([ac_ct_CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([ac_ct_CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^ac_ct_CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([CC]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CC]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CC$]) +m4trace:configure.ac:32: -1- AC_SUBST([EXEEXT], [$ac_cv_exeext]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([EXEEXT]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^EXEEXT$]) +m4trace:configure.ac:32: -1- AC_SUBST([OBJEXT], [$ac_cv_objext]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([OBJEXT]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^OBJEXT$]) +m4trace:configure.ac:32: -1- AC_REQUIRE_AUX_FILE([compile]) +m4trace:configure.ac:32: -1- AC_SUBST([DEPDIR], ["${am__leading_dot}deps"]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([DEPDIR]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^DEPDIR$]) +m4trace:configure.ac:32: -1- AC_SUBST([am__include]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([am__include]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^am__include$]) +m4trace:configure.ac:32: -1- AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +m4trace:configure.ac:32: -1- AC_SUBST([AMDEP_TRUE]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([AMDEP_TRUE]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^AMDEP_TRUE$]) +m4trace:configure.ac:32: -1- AC_SUBST([AMDEP_FALSE]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([AMDEP_FALSE]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^AMDEP_FALSE$]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([AMDEP_TRUE]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([AMDEP_FALSE]) +m4trace:configure.ac:32: -1- AC_SUBST([AMDEPBACKSLASH]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([AMDEPBACKSLASH]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^AMDEPBACKSLASH$]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([AMDEPBACKSLASH]) +m4trace:configure.ac:32: -1- AC_SUBST([am__nodep]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([am__nodep]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^am__nodep$]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([am__nodep]) +m4trace:configure.ac:32: -1- AC_SUBST([CCDEPMODE], [depmode=$am_cv_CC_dependencies_compiler_type]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([CCDEPMODE]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^CCDEPMODE$]) +m4trace:configure.ac:32: -1- AM_CONDITIONAL([am__fastdepCC], [ test "x$enable_dependency_tracking" != xno \ - && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) -]) -m4trace:/usr/share/aclocal-1.18/depend.m4:163: -1- AC_DEFUN([AM_SET_DEPDIR], [AC_REQUIRE([AM_SET_LEADING_DOT])dnl -AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl -]) -m4trace:/usr/share/aclocal-1.18/depend.m4:171: -1- AC_DEFUN([AM_DEP_TRACK], [AC_ARG_ENABLE([dependency-tracking], [dnl -AS_HELP_STRING( - [--enable-dependency-tracking], - [do not reject slow dependency extractors]) -AS_HELP_STRING( - [--disable-dependency-tracking], - [speeds up one-time build])]) -if test "x$enable_dependency_tracking" != xno; then - am_depcomp="$ac_aux_dir/depcomp" - AMDEPBACKSLASH='\' - am__nodep='_no' -fi -AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) -AC_SUBST([AMDEPBACKSLASH])dnl -_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl -AC_SUBST([am__nodep])dnl -_AM_SUBST_NOTMAKE([am__nodep])dnl -]) -m4trace:/usr/share/aclocal-1.18/depout.m4:11: -1- AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], [{ - # Older Autoconf quotes --file arguments for eval, but not when files - # are listed without --file. Let's play safe and only enable the eval - # if we detect the quoting. - # TODO: see whether this extra hack can be removed once we start - # requiring Autoconf 2.70 or later. - AS_CASE([$CONFIG_FILES], - [*\'*], [eval set x "$CONFIG_FILES"], - [*], [set x $CONFIG_FILES]) - shift - # Used to flag and report bootstrapping failures. - am_rc=0 - for am_mf - do - # Strip MF so we end up with the name of the file. - am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'` - # Check whether this is an Automake generated Makefile which includes - # dependency-tracking related rules and includes. - # Grep'ing the whole file directly is not great: AIX grep has a line - # limit of 2048, but all sed's we know have understand at least 4000. - sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \ - || continue - am_dirpart=`AS_DIRNAME(["$am_mf"])` - am_filepart=`AS_BASENAME(["$am_mf"])` - AM_RUN_LOG([cd "$am_dirpart" \ - && sed -e '/# am--include-marker/d' "$am_filepart" \ - | $MAKE -f - am--depfiles]) || am_rc=$? - done - if test $am_rc -ne 0; then - AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments - for automatic dependency tracking. If GNU make was not used, consider - re-running the configure script with MAKE="gmake" (or whatever is - necessary). You can also try re-running configure with the - '--disable-dependency-tracking' option to at least be able to build - the package (albeit without support for automatic dependency tracking).]) - fi - AS_UNSET([am_dirpart]) - AS_UNSET([am_filepart]) - AS_UNSET([am_mf]) - AS_UNSET([am_rc]) - rm -f conftest-deps.mk -} -]) -m4trace:/usr/share/aclocal-1.18/depout.m4:64: -1- AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], [AC_CONFIG_COMMANDS([depfiles], - [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], - [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])]) -m4trace:/usr/share/aclocal-1.18/init.m4:29: -1- AC_DEFUN([AM_INIT_AUTOMAKE], [AC_PREREQ([2.65])dnl -m4_ifdef([_$0_ALREADY_INIT], - [m4_fatal([$0 expanded multiple times -]m4_defn([_$0_ALREADY_INIT]))], - [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl -dnl Autoconf wants to disallow AM_ names. We explicitly allow -dnl the ones we care about. -m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl -AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl -AC_REQUIRE([AC_PROG_INSTALL])dnl -if test "`cd $srcdir && pwd`" != "`pwd`"; then - # Use -I$(srcdir) only when $(srcdir) != ., so that make's output - # is not polluted with repeated "-I." - AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl - # test to see if srcdir already configured - if test -f $srcdir/config.status; then - AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) - fi -fi - -# test whether we have cygpath -if test -z "$CYGPATH_W"; then - if (cygpath --version) >/dev/null 2>/dev/null; then - CYGPATH_W='cygpath -w' - else - CYGPATH_W=echo - fi -fi -AC_SUBST([CYGPATH_W]) - -# Define the identity of the package. -dnl Distinguish between old-style and new-style calls. -m4_ifval([$2], -[AC_DIAGNOSE([obsolete], - [$0: two- and three-arguments forms are deprecated.]) -m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl - AC_SUBST([PACKAGE], [$1])dnl - AC_SUBST([VERSION], [$2])], -[_AM_SET_OPTIONS([$1])dnl -dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. -m4_if( - m4_ifset([AC_PACKAGE_NAME], [ok]):m4_ifset([AC_PACKAGE_VERSION], [ok]), - [ok:ok],, - [m4_fatal([AC_INIT should be called with package and version arguments])])dnl - AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl - AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl - -_AM_IF_OPTION([no-define],, -[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) - AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl - -# Some tools Automake needs. -AC_REQUIRE([AM_SANITY_CHECK])dnl -AC_REQUIRE([AC_ARG_PROGRAM])dnl -AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) -AM_MISSING_PROG([AUTOCONF], [autoconf]) -AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) -AM_MISSING_PROG([AUTOHEADER], [autoheader]) -AM_MISSING_PROG([MAKEINFO], [makeinfo]) -AC_REQUIRE([AM_PROG_INSTALL_SH])dnl -AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl -AC_REQUIRE([AC_PROG_MKDIR_P])dnl -# For better backward compatibility. To be removed once Automake 1.9.x -# dies out for good. For more background, see: -# -# -AC_SUBST([mkdir_p], ['$(MKDIR_P)']) -# We need awk for the "check" target (and possibly the TAP driver). The -# system "awk" is bad on some platforms. -AC_REQUIRE([AC_PROG_AWK])dnl -AC_REQUIRE([AC_PROG_MAKE_SET])dnl -AC_REQUIRE([AM_SET_LEADING_DOT])dnl -_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], - [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], - [_AM_IF_OPTION([tar-v7], [_AM_PROG_TAR([v7])], - [_AM_PROG_TAR([ustar])])])]) -_AM_IF_OPTION([no-dependencies],, -[AC_PROVIDE_IFELSE([AC_PROG_CC], - [_AM_DEPENDENCIES([CC])], - [m4_define([AC_PROG_CC], - m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl -AC_PROVIDE_IFELSE([AC_PROG_CXX], - [_AM_DEPENDENCIES([CXX])], - [m4_define([AC_PROG_CXX], - m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl -AC_PROVIDE_IFELSE([AC_PROG_OBJC], - [_AM_DEPENDENCIES([OBJC])], - [m4_define([AC_PROG_OBJC], - m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl -AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], - [_AM_DEPENDENCIES([OBJCXX])], - [m4_define([AC_PROG_OBJCXX], - m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl -]) -# Variables for tags utilities; see am/tags.am -if test -z "$CTAGS"; then - CTAGS=ctags -fi -AC_SUBST([CTAGS]) -if test -z "$ETAGS"; then - ETAGS=etags -fi -AC_SUBST([ETAGS]) -if test -z "$CSCOPE"; then - CSCOPE=cscope -fi -AC_SUBST([CSCOPE]) - -AC_REQUIRE([_AM_SILENT_RULES])dnl -dnl The testsuite driver may need to know about EXEEXT, so add the -dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This -dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below. -AC_CONFIG_COMMANDS_PRE(dnl -[m4_provide_if([_AM_COMPILER_EXEEXT], - [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl - -AC_REQUIRE([_AM_PROG_RM_F]) -AC_REQUIRE([_AM_PROG_XARGS_N]) - -dnl The trailing newline in this macro's definition is deliberate, for -dnl backward compatibility and to allow trailing 'dnl'-style comments -dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841. -]) -m4trace:/usr/share/aclocal-1.18/init.m4:167: -1- AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], [# Compute $1's index in $config_headers. -_am_arg=$1 -_am_stamp_count=1 -for _am_header in $config_headers :; do - case $_am_header in - $_am_arg | $_am_arg:* ) - break ;; - * ) - _am_stamp_count=`expr $_am_stamp_count + 1` ;; - esac -done -echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) -m4trace:/usr/share/aclocal-1.18/install-sh.m4:11: -1- AC_DEFUN([AM_PROG_INSTALL_SH], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl -if test x"${install_sh+set}" != xset; then - case $am_aux_dir in - *\ * | *\ *) - install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; - *) - install_sh="\${SHELL} $am_aux_dir/install-sh" - esac -fi -AC_SUBST([install_sh])]) -m4trace:/usr/share/aclocal-1.18/lead-dot.m4:10: -1- AC_DEFUN([AM_SET_LEADING_DOT], [rm -rf .tst 2>/dev/null -mkdir .tst 2>/dev/null -if test -d .tst; then - am__leading_dot=. -else - am__leading_dot=_ -fi -rmdir .tst 2>/dev/null -AC_SUBST([am__leading_dot])]) -m4trace:/usr/share/aclocal-1.18/make.m4:13: -1- AC_DEFUN([AM_MAKE_INCLUDE], [AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive]) -cat > confinc.mk << 'END' -am__doit: - @echo this is the am__doit target >confinc.out -.PHONY: am__doit -END -am__include="#" -am__quote= -# BSD make does it like this. -echo '.include "confinc.mk" # ignored' > confmf.BSD -# Other make implementations (GNU, Solaris 10, AIX) do it like this. -echo 'include confinc.mk # ignored' > confmf.GNU -_am_result=no -for s in GNU BSD; do - AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out]) - AS_CASE([$?:`cat confinc.out 2>/dev/null`], - ['0:this is the am__doit target'], - [AS_CASE([$s], - [BSD], [am__include='.include' am__quote='"'], - [am__include='include' am__quote=''])]) - if test "$am__include" != "#"; then - _am_result="yes ($s style)" - break - fi -done -rm -f confinc.* confmf.* -AC_MSG_RESULT([${_am_result}]) -AC_SUBST([am__include])]) -m4trace:/usr/share/aclocal-1.18/make.m4:42: -1- m4_pattern_allow([^am__quote$]) -m4trace:/usr/share/aclocal-1.18/missing.m4:11: -1- AC_DEFUN([AM_MISSING_PROG], [AC_REQUIRE([AM_MISSING_HAS_RUN]) -$1=${$1-"${am_missing_run}$2"} -AC_SUBST($1)]) -m4trace:/usr/share/aclocal-1.18/missing.m4:20: -1- AC_DEFUN([AM_MISSING_HAS_RUN], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl -AC_REQUIRE_AUX_FILE([missing])dnl -if test x"${MISSING+set}" != xset; then - MISSING="\${SHELL} '$am_aux_dir/missing'" -fi -# Use eval to expand $SHELL -if eval "$MISSING --is-lightweight"; then - am_missing_run="$MISSING " -else - am_missing_run= - AC_MSG_WARN(['missing' script is too old or missing]) -fi -]) -m4trace:/usr/share/aclocal-1.18/options.m4:11: -1- AC_DEFUN([_AM_MANGLE_OPTION], [[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) -m4trace:/usr/share/aclocal-1.18/options.m4:17: -1- AC_DEFUN([_AM_SET_OPTION], [m4_define(_AM_MANGLE_OPTION([$1]), [1])]) -m4trace:/usr/share/aclocal-1.18/options.m4:23: -1- AC_DEFUN([_AM_SET_OPTIONS], [m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) -m4trace:/usr/share/aclocal-1.18/options.m4:29: -1- AC_DEFUN([_AM_IF_OPTION], [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) -m4trace:/usr/share/aclocal-1.18/prog-cc-c-o.m4:12: -1- AC_DEFUN([_AM_PROG_CC_C_O], [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl -AC_REQUIRE_AUX_FILE([compile])dnl -AC_LANG_PUSH([C])dnl -AC_CACHE_CHECK( - [whether $CC understands -c and -o together], - [am_cv_prog_cc_c_o], - [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) - # Make sure it works both with $CC and with simple cc. - # Following AC_PROG_CC_C_O, we do the test twice because some - # compilers refuse to overwrite an existing .o file with -o, - # though they will create one. - am_cv_prog_cc_c_o=yes - for am_i in 1 2; do - if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \ - && test -f conftest2.$ac_objext; then - : OK - else - am_cv_prog_cc_c_o=no - break - fi - done - # aligned with autoconf, so not including core; see bug#72225. - rm -f -r a.out a.exe b.out conftest.$ac_ext conftest.$ac_objext \ - conftest.dSYM conftest1.$ac_ext conftest1.$ac_objext conftest1.dSYM \ - conftest2.$ac_ext conftest2.$ac_objext conftest2.dSYM - unset am_i]) -if test "$am_cv_prog_cc_c_o" != yes; then - # Losing compiler, so override with the script. - # FIXME: It is wrong to rewrite CC. - # But if we don't then we get into trouble of one sort or another. - # A longer-term fix would be to have automake use am__CC in this case, - # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)" - CC="$am_aux_dir/compile $CC" -fi -AC_LANG_POP([C])]) -m4trace:/usr/share/aclocal-1.18/prog-cc-c-o.m4:50: -1- AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])]) -m4trace:/usr/share/aclocal-1.18/rmf.m4:12: -1- AC_DEFUN([_AM_PROG_RM_F], [am__rm_f_notfound= -AS_IF([(rm -f && rm -fr && rm -rf) 2>/dev/null], [], [am__rm_f_notfound='""']) -AC_SUBST(am__rm_f_notfound) -]) -m4trace:/usr/share/aclocal-1.18/runlog.m4:12: -1- AC_DEFUN([AM_RUN_LOG], [{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD - ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD - ac_status=$? - echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD - (exit $ac_status); }]) -m4trace:/usr/share/aclocal-1.18/sanity.m4:11: -1- AC_DEFUN([_AM_SLEEP_FRACTIONAL_SECONDS], [dnl -AC_CACHE_CHECK([whether sleep supports fractional seconds], - am_cv_sleep_fractional_seconds, [dnl -AS_IF([sleep 0.001 2>/dev/null], [am_cv_sleep_fractional_seconds=yes], - [am_cv_sleep_fractional_seconds=no]) -])]) -m4trace:/usr/share/aclocal-1.18/sanity.m4:28: -1- AC_DEFUN([_AM_FILESYSTEM_TIMESTAMP_RESOLUTION], [dnl -AC_REQUIRE([_AM_SLEEP_FRACTIONAL_SECONDS]) -AC_CACHE_CHECK([filesystem timestamp resolution], - am_cv_filesystem_timestamp_resolution, [dnl -# Default to the worst case. -am_cv_filesystem_timestamp_resolution=2 - -# Only try to go finer than 1 sec if sleep can do it. -# Don't try 1 sec, because if 0.01 sec and 0.1 sec don't work, -# - 1 sec is not much of a win compared to 2 sec, and -# - it takes 2 seconds to perform the test whether 1 sec works. -# -# Instead, just use the default 2s on platforms that have 1s resolution, -# accept the extra 1s delay when using $sleep in the Automake tests, in -# exchange for not incurring the 2s delay for running the test for all -# packages. -# -am_try_resolutions= -if test "$am_cv_sleep_fractional_seconds" = yes; then - # Even a millisecond often causes a bunch of false positives, - # so just try a hundredth of a second. The time saved between .001 and - # .01 is not terribly consequential. - am_try_resolutions="0.01 0.1 $am_try_resolutions" -fi - -# In order to catch current-generation FAT out, we must *modify* files -# that already exist; the *creation* timestamp is finer. Use names -# that make ls -t sort them differently when they have equal -# timestamps than when they have distinct timestamps, keeping -# in mind that ls -t prints the *newest* file first. -rm -f conftest.ts? -: > conftest.ts1 -: > conftest.ts2 -: > conftest.ts3 - -# Make sure ls -t actually works. Do 'set' in a subshell so we don't -# clobber the current shell's arguments. (Outer-level square brackets -# are removed by m4; they're present so that m4 does not expand -# ; be careful, easy to get confused.) -if ( - set X `[ls -t conftest.ts[12]]` && - { - test "$[]*" != "X conftest.ts1 conftest.ts2" || - test "$[]*" != "X conftest.ts2 conftest.ts1"; - } -); then :; else - # If neither matched, then we have a broken ls. This can happen - # if, for instance, CONFIG_SHELL is bash and it inherits a - # broken ls alias from the environment. This has actually - # happened. Such a system could not be considered "sane". - _AS_ECHO_UNQUOTED( - ["Bad output from ls -t: \"`[ls -t conftest.ts[12]]`\""], - [AS_MESSAGE_LOG_FD]) - AC_MSG_FAILURE([ls -t produces unexpected output. -Make sure there is not a broken ls alias in your environment.]) -fi - -for am_try_res in $am_try_resolutions; do - # Any one fine-grained sleep might happen to cross the boundary - # between two values of a coarser actual resolution, but if we do - # two fine-grained sleeps in a row, at least one of them will fall - # entirely within a coarse interval. - echo alpha > conftest.ts1 - sleep $am_try_res - echo beta > conftest.ts2 - sleep $am_try_res - echo gamma > conftest.ts3 - - # We assume that 'ls -t' will make use of high-resolution - # timestamps if the operating system supports them at all. - if (set X `ls -t conftest.ts?` && - test "$[]2" = conftest.ts3 && - test "$[]3" = conftest.ts2 && - test "$[]4" = conftest.ts1); then - # - # Ok, ls -t worked. If we're at a resolution of 1 second, we're done, - # because we don't need to test make. - make_ok=true - if test $am_try_res != 1; then - # But if we've succeeded so far with a subsecond resolution, we - # have one more thing to check: make. It can happen that - # everything else supports the subsecond mtimes, but make doesn't; - # notably on macOS, which ships make 3.81 from 2006 (the last one - # released under GPLv2). https://bugs.gnu.org/68808 - # - # We test $MAKE if it is defined in the environment, else "make". - # It might get overridden later, but our hope is that in practice - # it does not matter: it is the system "make" which is (by far) - # the most likely to be broken, whereas if the user overrides it, - # probably they did so with a better, or at least not worse, make. - # https://lists.gnu.org/archive/html/automake/2024-06/msg00051.html - # - # Create a Makefile (real tab character here): - rm -f conftest.mk - echo 'conftest.ts1: conftest.ts2' >conftest.mk - echo ' touch conftest.ts2' >>conftest.mk - # - # Now, running - # touch conftest.ts1; touch conftest.ts2; make - # should touch ts1 because ts2 is newer. This could happen by luck, - # but most often, it will fail if make's support is insufficient. So - # test for several consecutive successes. - # - # (We reuse conftest.ts[12] because we still want to modify existing - # files, not create new ones, per above.) - n=0 - make=${MAKE-make} - until test $n -eq 3; do - echo one > conftest.ts1 - sleep $am_try_res - echo two > conftest.ts2 # ts2 should now be newer than ts1 - if $make -f conftest.mk | grep 'up to date' >/dev/null; then - make_ok=false - break # out of $n loop - fi - n=`expr $n + 1` - done - fi - # - if $make_ok; then - # Everything we know to check worked out, so call this resolution good. - am_cv_filesystem_timestamp_resolution=$am_try_res - break # out of $am_try_res loop - fi - # Otherwise, we'll go on to check the next resolution. - fi -done -rm -f conftest.ts? -# (end _am_filesystem_timestamp_resolution) -])]) -m4trace:/usr/share/aclocal-1.18/sanity.m4:161: -1- AC_DEFUN([AM_SANITY_CHECK], [AC_REQUIRE([_AM_FILESYSTEM_TIMESTAMP_RESOLUTION]) -# This check should not be cached, as it may vary across builds of -# different projects. -AC_MSG_CHECKING([whether build environment is sane]) -# Reject unsafe characters in $srcdir or the absolute working directory -# name. Accept space and tab only in the latter. -am_lf=' -' -case `pwd` in - *[[\\\"\#\$\&\'\`$am_lf]]*) - AC_MSG_RESULT([no]) - AC_MSG_ERROR([unsafe absolute working directory name]);; -esac -case $srcdir in - *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) - AC_MSG_RESULT([no]) - AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; -esac - -# Do 'set' in a subshell so we don't clobber the current shell's -# arguments. Must try -L first in case configure is actually a -# symlink; some systems play weird games with the mod time of symlinks -# (eg FreeBSD returns the mod time of the symlink's containing -# directory). -am_build_env_is_sane=no -am_has_slept=no -rm -f conftest.file -for am_try in 1 2; do - echo "timestamp, slept: $am_has_slept" > conftest.file - if ( - set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` - if test "$[]*" = "X"; then - # -L didn't work. - set X `ls -t "$srcdir/configure" conftest.file` - fi - test "$[]2" = conftest.file - ); then - am_build_env_is_sane=yes - break - fi - # Just in case. - sleep "$am_cv_filesystem_timestamp_resolution" - am_has_slept=yes -done - -AC_MSG_RESULT([$am_build_env_is_sane]) -if test "$am_build_env_is_sane" = no; then - AC_MSG_ERROR([newly created file is older than distributed files! -Check your system clock]) -fi - -# If we didn't sleep, we still need to ensure time stamps of config.status and -# generated files are strictly newer. -am_sleep_pid= -AS_IF([test -e conftest.file || grep 'slept: no' conftest.file >/dev/null 2>&1],, [dnl - ( sleep "$am_cv_filesystem_timestamp_resolution" ) & - am_sleep_pid=$! -]) -AC_CONFIG_COMMANDS_PRE( - [AC_MSG_CHECKING([that generated files are newer than configure]) - if test -n "$am_sleep_pid"; then - # Hide warnings about reused PIDs. - wait $am_sleep_pid 2>/dev/null - fi - AC_MSG_RESULT([done])]) -rm -f conftest.file -]) -m4trace:/usr/share/aclocal-1.18/silent.m4:11: -1- AC_DEFUN([_AM_SILENT_RULES], [AM_DEFAULT_VERBOSITY=1 -AC_ARG_ENABLE([silent-rules], [dnl -AS_HELP_STRING( - [--enable-silent-rules], - [less verbose build output (undo: "make V=1")]) -AS_HELP_STRING( - [--disable-silent-rules], - [verbose build output (undo: "make V=0")])dnl -]) -dnl -dnl A few 'make' implementations (e.g., NonStop OS and NextStep) -dnl do not support nested variable expansions. -dnl See automake bug#9928 and bug#10237. -am_make=${MAKE-make} -AC_CACHE_CHECK([whether $am_make supports nested variables], - [am_cv_make_support_nested_variables], - [if AS_ECHO([['TRUE=$(BAR$(V)) -BAR0=false -BAR1=true -V=1 -am__doit: - @$(TRUE) -.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then - am_cv_make_support_nested_variables=yes -else - am_cv_make_support_nested_variables=no -fi]) -AC_SUBST([AM_V])dnl -AM_SUBST_NOTMAKE([AM_V])dnl -AC_SUBST([AM_DEFAULT_V])dnl -AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl -AC_SUBST([AM_DEFAULT_VERBOSITY])dnl -AM_BACKSLASH='\' -AC_SUBST([AM_BACKSLASH])dnl -_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl -dnl Delay evaluation of AM_DEFAULT_VERBOSITY to the end to allow multiple calls -dnl to AM_SILENT_RULES to change the default value. -AC_CONFIG_COMMANDS_PRE([dnl -case $enable_silent_rules in @%:@ ((( - yes) AM_DEFAULT_VERBOSITY=0;; - no) AM_DEFAULT_VERBOSITY=1;; -esac -if test $am_cv_make_support_nested_variables = yes; then - dnl Using '$V' instead of '$(V)' breaks IRIX make. - AM_V='$(V)' - AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)' -else - AM_V=$AM_DEFAULT_VERBOSITY - AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY -fi -])dnl -]) -m4trace:/usr/share/aclocal-1.18/silent.m4:69: -1- AC_DEFUN([AM_SILENT_RULES], [AC_REQUIRE([_AM_SILENT_RULES]) -AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1])m4_newline -dnl We intentionally force a newline after the assignment, since a) nothing -dnl good can come of more text following, and b) that was the behavior -dnl before 1.17. See https://bugs.gnu.org/72267. -]) -m4trace:/usr/share/aclocal-1.18/strip.m4:17: -1- AC_DEFUN([AM_PROG_INSTALL_STRIP], [AC_REQUIRE([AM_PROG_INSTALL_SH])dnl -# Installed binaries are usually stripped using 'strip' when the user -# run "make install-strip". However 'strip' might not be the right -# tool to use in cross-compilation environments, therefore Automake -# will honor the 'STRIP' environment variable to overrule this program. -dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. -if test "$cross_compiling" != no; then - AC_CHECK_TOOL([STRIP], [strip], :) -fi -INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" -AC_SUBST([INSTALL_STRIP_PROGRAM])]) -m4trace:/usr/share/aclocal-1.18/substnot.m4:12: -1- AC_DEFUN([_AM_SUBST_NOTMAKE]) -m4trace:/usr/share/aclocal-1.18/substnot.m4:17: -1- AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) -m4trace:/usr/share/aclocal-1.18/tar.m4:23: -1- AC_DEFUN([_AM_PROG_TAR], [# Always define AMTAR for backward compatibility. Yes, it's still used -# in the wild :-( We should find a proper way to deprecate it ... -AC_SUBST([AMTAR], ['$${TAR-tar}']) - -# We'll loop over all known methods to create a tar archive until one works. -_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' - -m4_if([$1], [v7], - [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], - - [m4_case([$1], - [ustar], - [# The POSIX 1988 'ustar' format is defined with fixed-size fields. - # There is notably a 21 bits limit for the UID and the GID. In fact, - # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343 - # and bug#13588). - am_max_uid=2097151 # 2^21 - 1 - am_max_gid=$am_max_uid - # The $UID and $GID variables are not portable, so we need to resort - # to the POSIX-mandated id(1) utility. Errors in the 'id' calls - # below are definitely unexpected, so allow the users to see them - # (that is, avoid stderr redirection). - am_uid=`id -u || echo unknown` - am_gid=`id -g || echo unknown` - AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format]) - if test x$am_uid = xunknown; then - AC_MSG_WARN([ancient id detected; assuming current UID is ok, but dist-ustar might not work]) - elif test $am_uid -le $am_max_uid; then - AC_MSG_RESULT([yes]) - else - AC_MSG_RESULT([no]) - _am_tools=none - fi - AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format]) - if test x$gm_gid = xunknown; then - AC_MSG_WARN([ancient id detected; assuming current GID is ok, but dist-ustar might not work]) - elif test $am_gid -le $am_max_gid; then - AC_MSG_RESULT([yes]) - else - AC_MSG_RESULT([no]) - _am_tools=none - fi], - - [pax], - [], - - [m4_fatal([Unknown tar format])]) - - AC_MSG_CHECKING([how to create a $1 tar archive]) - - # Go ahead even if we have the value already cached. We do so because we - # need to set the values for the 'am__tar' and 'am__untar' variables. - _am_tools=${am_cv_prog_tar_$1-$_am_tools} - - for _am_tool in $_am_tools; do - case $_am_tool in - gnutar) - for _am_tar in tar gnutar gtar; do - AM_RUN_LOG([$_am_tar --version]) && break - done - am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' - am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' - am__untar="$_am_tar -xf -" - ;; - plaintar) - # Must skip GNU tar: if it does not support --format= it doesn't create - # ustar tarball either. - (tar --version) >/dev/null 2>&1 && continue - am__tar='tar chf - "$$tardir"' - am__tar_='tar chf - "$tardir"' - am__untar='tar xf -' - ;; - pax) - am__tar='pax -L -x $1 -w "$$tardir"' - am__tar_='pax -L -x $1 -w "$tardir"' - am__untar='pax -r' - ;; - cpio) - am__tar='find "$$tardir" -print | cpio -o -H $1 -L' - am__tar_='find "$tardir" -print | cpio -o -H $1 -L' - am__untar='cpio -i -H $1 -d' - ;; - none) - am__tar=false - am__tar_=false - am__untar=false - ;; - esac - - # If the value was cached, stop now. We just wanted to have am__tar - # and am__untar set. - test -n "${am_cv_prog_tar_$1}" && break - - # tar/untar a dummy directory, and stop if the command works. - rm -rf conftest.dir - mkdir conftest.dir - echo GrepMe > conftest.dir/file - AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) - rm -rf conftest.dir - if test -s conftest.tar; then - AM_RUN_LOG([$am__untar /dev/null 2>&1 && break - fi - done - rm -rf conftest.dir - - AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) - AC_MSG_RESULT([$am_cv_prog_tar_$1])]) - -AC_SUBST([am__tar]) -AC_SUBST([am__untar]) -]) -m4trace:/usr/share/aclocal-1.18/xargsn.m4:12: -1- AC_DEFUN([_AM_PROG_XARGS_N], [AC_CACHE_CHECK([xargs -n works], am_cv_xargs_n_works, [dnl -AS_IF([test "`echo 1 2 3 | xargs -n2 echo`" = "1 2 -3"], [am_cv_xargs_n_works=yes], [am_cv_xargs_n_works=no])]) -AS_IF([test "$am_cv_xargs_n_works" = yes], [am__xargs_n='xargs -n'], [dnl - am__xargs_n='am__xargs_n () { shift; sed "s/ /\\n/g" | while read am__xargs_n_arg; do "$@" "$am__xargs_n_arg"; done; }' -])dnl -AC_SUBST(am__xargs_n) -]) -m4trace:gnulib-m4/00gnulib.m4:24: -1- AC_DEFUN([gl_COMPILER_CLANG], [ -dnl AC_REQUIRE([AC_PROG_CC]) - AC_CACHE_CHECK([whether the compiler is clang], - [gl_cv_compiler_clang], - [dnl Use _AC_COMPILE_IFELSE instead of AC_EGREP_CPP, to avoid error - dnl "circular dependency of AC_LANG_COMPILER(C)" if AC_PROG_CC has - dnl not yet been invoked. - _AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #ifdef __clang__ - barfbarf - #endif - ]],[[]]) - ], - [gl_cv_compiler_clang=no], - [gl_cv_compiler_clang=yes]) - ]) -]) -m4trace:gnulib-m4/00gnulib.m4:43: -1- AC_DEFUN([gl_COMPILER_PREPARE_CHECK_DECL], [ -dnl AC_REQUIRE([AC_PROG_CC]) -dnl AC_REQUIRE([gl_COMPILER_CLANG]) - AC_CACHE_CHECK([for compiler option needed when checking for declarations], - [gl_cv_compiler_check_decl_option], - [if test $gl_cv_compiler_clang = yes; then - dnl Test whether the compiler supports the option - dnl '-Werror=implicit-function-declaration'. - saved_ac_compile="$ac_compile" - ac_compile="$ac_compile -Werror=implicit-function-declaration" - dnl Use _AC_COMPILE_IFELSE instead of AC_COMPILE_IFELSE, to avoid a - dnl warning "AC_COMPILE_IFELSE was called before AC_USE_SYSTEM_EXTENSIONS". - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])], - [gl_cv_compiler_check_decl_option='-Werror=implicit-function-declaration'], - [gl_cv_compiler_check_decl_option=none]) - ac_compile="$saved_ac_compile" - else - gl_cv_compiler_check_decl_option=none - fi - ]) - if test "x$gl_cv_compiler_check_decl_option" != xnone; then - ac_compile_for_check_decl="$ac_compile $gl_cv_compiler_check_decl_option" - else - ac_compile_for_check_decl="$ac_compile" - fi -]) -m4trace:gnulib-m4/00gnulib.m4:85: -1- AC_DEFUN([gl_00GNULIB]) -m4trace:gnulib-m4/__inline.m4:7: -1- AC_DEFUN([gl___INLINE], [ - AC_CACHE_CHECK([whether the compiler supports the __inline keyword], - [gl_cv_c___inline], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[typedef int foo_t; - static __inline foo_t foo (void) { return 0; }]], - [[return foo ();]])], - [gl_cv_c___inline=yes], - [gl_cv_c___inline=no])]) - if test $gl_cv_c___inline = yes; then - AC_DEFINE([HAVE___INLINE], [1], - [Define to 1 if the compiler supports the keyword '__inline'.]) - fi -]) -m4trace:gnulib-m4/absolute-header.m4:22: -1- AC_DEFUN([gl_ABSOLUTE_HEADER], [AC_REQUIRE([AC_CANONICAL_HOST]) -AC_LANG_PREPROC_REQUIRE()dnl -m4_foreach_w([gl_HEADER_NAME], [$1], - [AS_VAR_PUSHDEF([gl_absolute_header], - [gl_cv_absolute_]m4_defn([gl_HEADER_NAME]))dnl - AC_CACHE_CHECK([absolute name of <]m4_defn([gl_HEADER_NAME])[>], - [gl_absolute_header], - [AS_VAR_PUSHDEF([ac_header_exists], - [ac_cv_header_]m4_defn([gl_HEADER_NAME]))dnl - AC_CHECK_HEADERS_ONCE(m4_defn([gl_HEADER_NAME]))dnl - if test AS_VAR_GET([ac_header_exists]) = yes; then - gl_ABSOLUTE_HEADER_ONE(m4_defn([gl_HEADER_NAME])) - fi - AS_VAR_POPDEF([ac_header_exists])dnl - ])dnl - AC_DEFINE_UNQUOTED(AS_TR_CPP([ABSOLUTE_]m4_defn([gl_HEADER_NAME])), - ["AS_VAR_GET([gl_absolute_header])"], - [Define this to an absolute name of <]m4_defn([gl_HEADER_NAME])[>.]) - AS_VAR_POPDEF([gl_absolute_header])dnl -])dnl -]) -m4trace:gnulib-m4/absolute-header.m4:52: -1- AC_DEFUN([gl_ABSOLUTE_HEADER_ONE], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_LANG_CONFTEST([AC_LANG_SOURCE([[#include <]]m4_dquote([$1])[[>]])]) - dnl AIX "xlc -E" and "cc -E" omit #line directives for header files - dnl that contain only a #include of other header files and no - dnl non-comment tokens of their own. This leads to a failure to - dnl detect the absolute name of , , - dnl and others. The workaround is to force preservation of comments - dnl through option -C. This ensures all necessary #line directives - dnl are present. GCC supports option -C as well. - case "$host_os" in - aix*) gl_absname_cpp="$ac_cpp -C" ;; - *) gl_absname_cpp="$ac_cpp" ;; - esac -changequote(,) - case "$host_os" in - mingw* | windows*) - dnl For the sake of native Windows compilers (excluding gcc), - dnl treat backslash as a directory separator, like /. - dnl Actually, these compilers use a double-backslash as - dnl directory separator, inside the - dnl # line "filename" - dnl directives. - gl_dirsep_regex='[/\\]' - ;; - *) - gl_dirsep_regex='\/' - ;; - esac - dnl A sed expression that turns a string into a basic regular - dnl expression, for use within "/.../". - gl_make_literal_regex_sed='s,[]$^\\.*/[],\\&,g' - gl_header_literal_regex=`echo '$1' \ - | sed -e "$gl_make_literal_regex_sed"` - gl_absolute_header_sed="/${gl_dirsep_regex}${gl_header_literal_regex}/"'{ - s/.*"\(.*'"${gl_dirsep_regex}${gl_header_literal_regex}"'\)".*/\1/ - s|^/[^/]|//&| - p - q - }' -changequote([,]) - dnl eval is necessary to expand gl_absname_cpp. - dnl Ultrix and Pyramid sh refuse to redirect output of eval, - dnl so use subshell. - AS_VAR_SET([gl_cv_absolute_]AS_TR_SH([[$1]]), -[`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&AS_MESSAGE_LOG_FD | - sed -n "$gl_absolute_header_sed"`]) -]) -m4trace:gnulib-m4/alloca.m4:8: -1- AC_DEFUN([gl_FUNC_ALLOCA], [ - AC_REQUIRE([AC_FUNC_ALLOCA]) - if test $ac_cv_func_alloca_works = no; then - gl_PREREQ_ALLOCA - fi - - # Define an additional variable used in the Makefile substitution. - if test $ac_cv_working_alloca_h = yes; then - AC_CACHE_CHECK([for alloca as a compiler built-in], [gl_cv_rpl_alloca], [ - AC_EGREP_CPP([Need own alloca], [ -#if defined __GNUC__ || defined _AIX || defined _MSC_VER - Need own alloca + && test "$am_cv_CC_dependencies_compiler_type" = gcc3]) +m4trace:configure.ac:32: -1- AC_SUBST([am__fastdepCC_TRUE]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([am__fastdepCC_TRUE]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^am__fastdepCC_TRUE$]) +m4trace:configure.ac:32: -1- AC_SUBST([am__fastdepCC_FALSE]) +m4trace:configure.ac:32: -1- AC_SUBST_TRACE([am__fastdepCC_FALSE]) +m4trace:configure.ac:32: -1- m4_pattern_allow([^am__fastdepCC_FALSE$]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([am__fastdepCC_TRUE]) +m4trace:configure.ac:32: -1- _AM_SUBST_NOTMAKE([am__fastdepCC_FALSE]) +m4trace:configure.ac:35: -1- AC_SUBST([JAVA_CHOICE]) +m4trace:configure.ac:35: -1- AC_SUBST_TRACE([JAVA_CHOICE]) +m4trace:configure.ac:35: -1- m4_pattern_allow([^JAVA_CHOICE$]) +m4trace:configure.ac:36: -1- AC_SUBST([CPP]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CPP]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CPP$]) +m4trace:configure.ac:36: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:36: -1- AC_SUBST([CPP]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CPP]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CPP$]) +m4trace:configure.ac:36: -1- AC_SUBST([HAVE_JAVAC_IN_PATH]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([HAVE_JAVAC_IN_PATH]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^HAVE_JAVAC_IN_PATH$]) +m4trace:configure.ac:36: -1- AC_SUBST([CONF_JAVAC]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CONF_JAVAC]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CONF_JAVAC$]) +m4trace:configure.ac:36: -1- AC_SUBST([CLASSPATH]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CLASSPATH]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CLASSPATH$]) +m4trace:configure.ac:36: -1- AC_SUBST([CLASSPATH_SEPARATOR]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CLASSPATH_SEPARATOR]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CLASSPATH_SEPARATOR$]) +m4trace:configure.ac:36: -1- AC_SUBST([HAVE_JAVAC_ENVVAR]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([HAVE_JAVAC_ENVVAR]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^HAVE_JAVAC_ENVVAR$]) +m4trace:configure.ac:36: -1- AC_SUBST([HAVE_JAVAC]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([HAVE_JAVAC]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^HAVE_JAVAC$]) +m4trace:configure.ac:36: -1- AC_SUBST([JAR]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([JAR]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^JAR$]) +m4trace:configure.ac:36: -1- AC_SUBST([CONF_JAVAC]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([CONF_JAVAC]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^CONF_JAVAC$]) +m4trace:configure.ac:36: -1- AC_SUBST([HAVE_JAVAC_ENVVAR]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([HAVE_JAVAC_ENVVAR]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^HAVE_JAVAC_ENVVAR$]) +m4trace:configure.ac:36: -1- AC_SUBST([HAVE_JAVAC]) +m4trace:configure.ac:36: -1- AC_SUBST_TRACE([HAVE_JAVAC]) +m4trace:configure.ac:36: -1- m4_pattern_allow([^HAVE_JAVAC$]) +m4trace:configure.ac:49: -1- AC_SUBST([BUILDJAVA]) +m4trace:configure.ac:49: -1- AC_SUBST_TRACE([BUILDJAVA]) +m4trace:configure.ac:49: -1- m4_pattern_allow([^BUILDJAVA$]) +m4trace:configure.ac:51: -1- AC_SUBST([CSHARP_CHOICE]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([CSHARP_CHOICE]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^CSHARP_CHOICE$]) +m4trace:configure.ac:51: -1- AC_DEFINE_TRACE_LITERAL([CSHARP_CHOICE_MONO]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^CSHARP_CHOICE_MONO$]) +m4trace:configure.ac:51: -1- AH_OUTPUT([CSHARP_CHOICE_MONO], [/* Define if mono is the preferred C@%:@ implementation. */ +@%:@undef CSHARP_CHOICE_MONO]) +m4trace:configure.ac:51: -1- AC_SUBST([HAVE_MCS_IN_PATH]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([HAVE_MCS_IN_PATH]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^HAVE_MCS_IN_PATH$]) +m4trace:configure.ac:51: -1- AC_SUBST([HAVE_CSC_IN_PATH]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([HAVE_CSC_IN_PATH]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^HAVE_CSC_IN_PATH$]) +m4trace:configure.ac:51: -1- AC_SUBST([HAVE_MCS]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([HAVE_MCS]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^HAVE_MCS$]) +m4trace:configure.ac:51: -1- AC_SUBST([HAVE_CSC]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([HAVE_CSC]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^HAVE_CSC$]) +m4trace:configure.ac:51: -1- AC_SUBST([CSHARPCOMPFLAGS]) +m4trace:configure.ac:51: -1- AC_SUBST_TRACE([CSHARPCOMPFLAGS]) +m4trace:configure.ac:51: -1- m4_pattern_allow([^CSHARPCOMPFLAGS$]) +m4trace:configure.ac:57: -1- AC_SUBST([BUILDCSHARP]) +m4trace:configure.ac:57: -1- AC_SUBST_TRACE([BUILDCSHARP]) +m4trace:configure.ac:57: -1- m4_pattern_allow([^BUILDCSHARP$]) +m4trace:configure.ac:60: -1- AC_CANONICAL_HOST +m4trace:configure.ac:60: -1- AC_CANONICAL_BUILD +m4trace:configure.ac:60: -1- AC_REQUIRE_AUX_FILE([config.sub]) +m4trace:configure.ac:60: -1- AC_REQUIRE_AUX_FILE([config.guess]) +m4trace:configure.ac:60: -1- AC_SUBST([build], [$ac_cv_build]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([build]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^build$]) +m4trace:configure.ac:60: -1- AC_SUBST([build_cpu], [$[1]]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([build_cpu]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^build_cpu$]) +m4trace:configure.ac:60: -1- AC_SUBST([build_vendor], [$[2]]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([build_vendor]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^build_vendor$]) +m4trace:configure.ac:60: -1- AC_SUBST([build_os]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([build_os]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^build_os$]) +m4trace:configure.ac:60: -1- AC_SUBST([host], [$ac_cv_host]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([host]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^host$]) +m4trace:configure.ac:60: -1- AC_SUBST([host_cpu], [$[1]]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([host_cpu]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^host_cpu$]) +m4trace:configure.ac:60: -1- AC_SUBST([host_vendor], [$[2]]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([host_vendor]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^host_vendor$]) +m4trace:configure.ac:60: -1- AC_SUBST([host_os]) +m4trace:configure.ac:60: -1- AC_SUBST_TRACE([host_os]) +m4trace:configure.ac:60: -1- m4_pattern_allow([^host_os$]) +m4trace:configure.ac:67: -1- AC_SUBST([AR]) +m4trace:configure.ac:67: -1- AC_SUBST_TRACE([AR]) +m4trace:configure.ac:67: -1- m4_pattern_allow([^AR$]) +m4trace:configure.ac:67: -1- AC_SUBST([AR]) +m4trace:configure.ac:67: -1- AC_SUBST_TRACE([AR]) +m4trace:configure.ac:67: -1- m4_pattern_allow([^AR$]) +m4trace:configure.ac:67: -1- AC_SUBST([ARFLAGS]) +m4trace:configure.ac:67: -1- AC_SUBST_TRACE([ARFLAGS]) +m4trace:configure.ac:67: -1- m4_pattern_allow([^ARFLAGS$]) +m4trace:configure.ac:67: -1- AC_SUBST([RANLIB]) +m4trace:configure.ac:67: -1- AC_SUBST_TRACE([RANLIB]) +m4trace:configure.ac:67: -1- m4_pattern_allow([^RANLIB$]) +m4trace:configure.ac:67: -1- AC_SUBST([RANLIB]) +m4trace:configure.ac:67: -1- AC_SUBST_TRACE([RANLIB]) +m4trace:configure.ac:67: -1- m4_pattern_allow([^RANLIB$]) +m4trace:configure.ac:73: -1- m4_pattern_forbid([^gl_[A-Z]]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^gl_ES$]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^gl_LIBOBJS$]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^gl_LTLIBOBJS$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([USE_SYSTEM_EXTENSIONS], [/* Enable extensions on AIX, Interix, z/OS. */ +#ifndef _ALL_SOURCE +# undef _ALL_SOURCE #endif - ], [gl_cv_rpl_alloca=yes], [gl_cv_rpl_alloca=no]) - ]) - if test $gl_cv_rpl_alloca = yes; then - dnl OK, alloca can be implemented through a compiler built-in. - AC_DEFINE([HAVE_ALLOCA], [1], - [Define to 1 if you have 'alloca' after including , - a header that may be supplied by this distribution.]) - GL_GENERATE_ALLOCA_H=true - else - dnl alloca exists as a library function, i.e. it is slow and probably - dnl a memory leak. Don't define HAVE_ALLOCA in this case. - GL_GENERATE_ALLOCA_H=false - fi - else - GL_GENERATE_ALLOCA_H=true - fi - - if test $ac_cv_working_alloca_h = yes; then - HAVE_ALLOCA_H=1 - else - HAVE_ALLOCA_H=0 - fi - AC_SUBST([HAVE_ALLOCA_H]) -]) -m4trace:gnulib-m4/alloca.m4:49: -1- AC_DEFUN([gl_PREREQ_ALLOCA], [:]) -m4trace:gnulib-m4/ansi-c++.m4:15: -1- AC_DEFUN([gl_CXX_CHOICE], [ - AC_MSG_CHECKING([whether to use C++]) - dnl Plus signs are supported in AC_ARG_ENABLE starting with autoconf-2.66. - m4_version_prereq([2.66], - [m4_ifdef([gl_CXX_CHOICE_DEFAULT_NO], - [AC_ARG_ENABLE([c++], - [ --enable-c++ also build C++ sources], - [CXX_CHOICE="$enableval"], - [CXX_CHOICE=no])], - [AC_ARG_ENABLE([c++], - [ --disable-c++ do not build C++ sources], - [CXX_CHOICE="$enableval"], - [CXX_CHOICE=yes])])], - [m4_ifdef([gl_CXX_CHOICE_DEFAULT_NO], - [AC_ARG_ENABLE([cxx], - [ --enable-cxx also build C++ sources], - [CXX_CHOICE="$enableval"], - [CXX_CHOICE=no])], - [AC_ARG_ENABLE([cxx], - [ --disable-cxx do not build C++ sources], - [CXX_CHOICE="$enableval"], - [CXX_CHOICE=yes])])]) - AC_MSG_RESULT([$CXX_CHOICE]) - AC_SUBST([CXX_CHOICE]) -]) -m4trace:gnulib-m4/ansi-c++.m4:48: -1- AC_DEFUN([gl_PROG_ANSI_CXX], [ - AC_REQUIRE([gl_CXX_CHOICE]) - m4_if([$1], [CXX], [], - [gl_saved_CXX="$CXX"]) - if test "$CXX_CHOICE" = no; then - CXX=no - fi - if test -z "$CXX"; then - if test -n "$CCC"; then - CXX="$CCC" - else - AC_CHECK_TOOLS([CXX], - [g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC], - [:]) - fi - fi - if test "$CXX" != no; then - dnl Use a modified version of AC_PROG_CXX_WORKS that does not exit - dnl upon failure. - AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works]) - AC_LANG_PUSH([C++]) - AC_ARG_VAR([CXX], [C++ compiler command]) - AC_ARG_VAR([CXXFLAGS], [C++ compiler flags]) - echo 'int main () { return 0; }' > conftest.$ac_ext - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - gl_cv_prog_ansicxx_works=yes - if (./conftest; exit) 2>/dev/null; then - gl_cv_prog_ansicxx_cross=no - else - gl_cv_prog_ansicxx_cross=yes - fi - else - gl_cv_prog_ansicxx_works=no - fi - rm -fr conftest* - AC_LANG_POP([C++]) - AC_MSG_RESULT([$gl_cv_prog_ansicxx_works]) - if test $gl_cv_prog_ansicxx_works = no; then - CXX=no - else - dnl Test for namespaces. - dnl We don't bother supporting pre-ANSI-C++ compilers. - AC_MSG_CHECKING([whether the C++ compiler supports namespaces]) - AC_LANG_PUSH([C++]) - cat < conftest.$ac_ext -#include -namespace test { using namespace std; } -std::ostream* ptr; -int main () { return 0; } -EOF - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - gl_cv_prog_ansicxx_namespaces=yes - else - gl_cv_prog_ansicxx_namespaces=no - fi - rm -fr conftest* - AC_LANG_POP([C++]) - AC_MSG_RESULT([$gl_cv_prog_ansicxx_namespaces]) - if test $gl_cv_prog_ansicxx_namespaces = no; then - CXX=no - fi - fi - fi - m4_if([$1], [CXX], [], - [$1="$CXX" - CXX="$gl_saved_CXX"]) - AC_SUBST([$1]) - - AM_CONDITIONAL([$2], [test "$$1" != no]) - - if test "$$1" != no; then - dnl This macro invocation resolves an automake error: - dnl /usr/local/share/automake-1.11/am/depend2.am: am__fastdepCXX does not appear in AM_CONDITIONAL - dnl /usr/local/share/automake-1.11/am/depend2.am: The usual way to define 'am__fastdepCXX' is to add 'AC_PROG_CXX' - dnl /usr/local/share/automake-1.11/am/depend2.am: to 'configure.ac' and run 'aclocal' and 'autoconf' again. - _AM_DEPENDENCIES([CXX]) - dnl Determine a good default for the CXXFLAGS variable. - AC_LANG_PUSH([C++]) - _AC_LANG_COMPILER_GNU - if test $ac_compiler_gnu = yes; then - GXX=yes - else - GXX= - fi - _AC_PROG_CXX_G - AC_LANG_POP([C++]) - else - AM_CONDITIONAL([am__fastdepCXX], [false]) - fi -]) -m4trace:gnulib-m4/ansi-c++.m4:145: -1- AC_DEFUN([gl_ANSI_CXX], [ - gl_PROG_ANSI_CXX([CXX], [ANSICXX]) - dnl This line is needed in order to avoid trouble with Autoconf. It makes - dnl sure that Autoconf does not insert expansions of AC_PROG_CXX at random - dnl places. See . - m4_provide([AC_PROG_CXX]) -]) -m4trace:gnulib-m4/asm-underscore.m4:15: -1- AC_DEFUN([gl_ASM_SYMBOL_PREFIX], [ - AC_REQUIRE([AC_PROG_EGREP]) - dnl We don't use GCC's __USER_LABEL_PREFIX__ here, because - dnl 1. It works only for GCC. - dnl 2. It is incorrectly defined on some platforms, in some GCC versions. - AC_REQUIRE([gl_C_ASM]) - AC_CACHE_CHECK( - [whether C symbols are prefixed with underscore at the linker level], - [gl_cv_prog_as_underscore], - [cat > conftest.c </dev/null 2>&1 - if LC_ALL=C $EGREP '(^|[[^a-zA-Z0-9_]])_foo([[^a-zA-Z0-9_]]|$)' conftest.$gl_asmext >/dev/null; then - gl_cv_prog_as_underscore=yes - else - gl_cv_prog_as_underscore=no - fi - rm -f conftest* - ]) - if test $gl_cv_prog_as_underscore = yes; then - USER_LABEL_PREFIX=_ - else - USER_LABEL_PREFIX= - fi - AC_DEFINE_UNQUOTED([USER_LABEL_PREFIX], [$USER_LABEL_PREFIX], - [Define to the prefix of C symbols at the assembler and linker level, - either an underscore or empty.]) - ASM_SYMBOL_PREFIX='"'${USER_LABEL_PREFIX}'"' - AC_SUBST([ASM_SYMBOL_PREFIX]) -]) -m4trace:gnulib-m4/asm-underscore.m4:58: -1- AC_DEFUN([gl_C_ASM], [ - AC_EGREP_CPP([MicrosoftCompiler], - [ -#ifdef _MSC_VER -MicrosoftCompiler +/* Enable general extensions on macOS. */ +#ifndef _DARWIN_C_SOURCE +# undef _DARWIN_C_SOURCE #endif - ], - [dnl Microsoft's 'cl' and 'clang-cl' produce an .asm file, whereas 'clang' - dnl produces a .s file. Need to distinguish 'clang' and 'clang-cl'. - rm -f conftest* - echo 'int dummy;' > conftest.c - AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS -c conftest.c) >/dev/null 2>&1 - if test -f conftest.o; then - gl_asmext='s' - gl_c_asm_opt='-S' - else - gl_asmext='asm' - gl_c_asm_opt='-c -Fa' - fi - rm -f conftest* - ], - [gl_asmext='s' - gl_c_asm_opt='-S' - ]) -]) -m4trace:gnulib-m4/assert_h.m4:9: -1- AC_DEFUN([gl_ASSERT_H], [ - AC_CACHE_CHECK([for static_assert], [gl_cv_static_assert], - [gl_saved_CFLAGS=$CFLAGS - for gl_working in "yes, a keyword" "yes, an macro"; do - AS_CASE([$gl_working], - [*assert.h*], [CFLAGS="$gl_saved_CFLAGS -DINCLUDE_ASSERT_H"]) - - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#if defined __clang__ && __STDC_VERSION__ < 202311 - #pragma clang diagnostic error "-Wc2x-extensions" - #pragma clang diagnostic error "-Wc++1z-extensions" - #endif - #ifdef INCLUDE_ASSERT_H - #include - #endif - static_assert (2 + 2 == 4, "arithmetic does not work"); - static_assert (2 + 2 == 4); - ]], - [[ - static_assert (sizeof (char) == 1, "sizeof does not work"); - static_assert (sizeof (char) == 1); - ]])], - [gl_cv_static_assert=$gl_working], - [gl_cv_static_assert=no]) - CFLAGS=$gl_saved_CFLAGS - test "$gl_cv_static_assert" != no && break - done]) - - GL_GENERATE_ASSERT_H=false - AS_CASE([$gl_cv_static_assert], - [yes*keyword*], - [AC_DEFINE([HAVE_C_STATIC_ASSERT], [1], - [Define to 1 if the static_assert keyword works.])], - [no], - [GL_GENERATE_ASSERT_H=true - gl_NEXT_HEADERS([assert.h])]) - - dnl The "zz" puts this toward config.h's end, to avoid potential - dnl collisions with other definitions. - dnl #undef assert so that programs are not tempted to use it without - dnl specifically including assert.h. - dnl #undef __ASSERT_H__ so that on IRIX, when programs later include - dnl , this include actually defines assert. - dnl Break the #undef_s apart with a comment so that 'configure' does - dnl not comment them out. - AH_VERBATIM([zzstatic_assert], -[#if (!defined HAVE_C_STATIC_ASSERT && !defined assert \ - && (!defined __cplusplus \ - || (__cpp_static_assert < 201411 \ - && __GNUG__ < 6 && __clang_major__ < 6))) - #include - #undef/**/assert - #ifdef __sgi - #undef/**/__ASSERT_H__ - #endif - /* Solaris 11.4 defines static_assert as a macro with 2 arguments. - We need it also to be invocable with a single argument. */ - #if defined __sun && (__STDC_VERSION__ - 0 >= 201112L) && !defined __cplusplus - #undef/**/static_assert - #define static_assert _Static_assert - #endif -#endif]) -]) -m4trace:gnulib-m4/atexit.m4:7: -1- AC_DEFUN([gl_FUNC_ATEXIT], [ - AC_CHECK_FUNCS([atexit]) -]) -m4trace:gnulib-m4/atexit.m4:13: -1- AC_DEFUN([gl_PREREQ_ATEXIT], [ - : -]) -m4trace:gnulib-m4/builtin-expect.m4:10: -1- AC_DEFUN([gl___BUILTIN_EXPECT], [ - AC_CACHE_CHECK([for __builtin_expect], - [gl_cv___builtin_expect], - [AC_LINK_IFELSE( - [AC_LANG_SOURCE([[ - int - main (int argc, char **argv) - { - argc = __builtin_expect (argc, 100); - return argv[argc != 100][0]; - }]])], - [gl_cv___builtin_expect=yes], - [AC_LINK_IFELSE( - [AC_LANG_SOURCE([[ - #include - int - main (int argc, char **argv) - { - argc = __builtin_expect (argc, 100); - return argv[argc != 100][0]; - }]])], - [gl_cv___builtin_expect="in "], - [gl_cv___builtin_expect=no])])]) - if test "$gl_cv___builtin_expect" = yes; then - AC_DEFINE([HAVE___BUILTIN_EXPECT], [1]) - elif test "$gl_cv___builtin_expect" = "in "; then - AC_DEFINE([HAVE___BUILTIN_EXPECT], [2]) - fi - AH_VERBATIM([HAVE___BUILTIN_EXPECT], - [/* Define to 1 if the compiler supports __builtin_expect, - and to 2 if does. */ -#undef HAVE___BUILTIN_EXPECT -#ifndef HAVE___BUILTIN_EXPECT -# define __builtin_expect(e, c) (e) -#elif HAVE___BUILTIN_EXPECT == 2 -# include +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# undef __EXTENSIONS__ #endif - ]) -]) -m4trace:gnulib-m4/c-bool.m4:8: -1- AC_DEFUN([gl_C_BOOL], [ - AC_CACHE_CHECK([for bool, true, false], [gl_cv_c_bool], - [AC_COMPILE_IFELSE( - [AC_LANG_SOURCE([[ - #if true == false - #error "true == false" - #endif - extern bool b; - bool b = true == false;]])], - [gl_cv_c_bool=yes], - [gl_cv_c_bool=no])]) - if test "$gl_cv_c_bool" = yes; then - AC_DEFINE([HAVE_C_BOOL], [1], - [Define to 1 if bool, true and false work as per C2023.]) - fi - - AC_CHECK_HEADERS_ONCE([stdbool.h]) - - dnl The "zz" puts this toward config.h's end, to avoid potential - dnl collisions with other definitions. - dnl If 'bool', 'true' and 'false' do not work, arrange for them to work. - dnl In C, this means including if it is not already included. - dnl However, if the preprocessor mistakenly treats 'true' as 0, - dnl define it to a bool expression equal to 1; this is needed in - dnl Sun C++ 5.11 (Oracle Solaris Studio 12.2, 2010) and older. - AH_VERBATIM([zzbool], -[#ifndef HAVE_C_BOOL -# if !defined __cplusplus && !defined __bool_true_false_are_defined -# if HAVE_STDBOOL_H -# include -# else -# if defined __SUNPRO_C -# error " is not usable with this configuration. To make it usable, add -D_STDC_C99= to $CC." -# else -# error " does not exist on this platform. Use gnulib module 'stdbool-c99' instead of gnulib module 'stdbool'." -# endif -# endif -# endif -# if !true -# define true (!false) -# endif -#endif]) -]) -m4trace:gnulib-m4/calloc.m4:18: -1- AC_DEFUN([_AC_FUNC_CALLOC_IF], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether calloc (0, n) and calloc (n, 0) return nonnull], - [ac_cv_func_calloc_0_nonnull], - [if test $cross_compiling != yes; then - ac_cv_func_calloc_0_nonnull=yes - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [AC_INCLUDES_DEFAULT], - [[int result = 0; - char * volatile p = calloc (0, 0); - if (!p) - result |= 1; - free (p); - return result; - ]])], - [], - [ac_cv_func_calloc_0_nonnull=no]) - else - case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) ac_cv_func_calloc_0_nonnull="guessing yes" ;; - # Guess yes on musl systems. - *-musl* | midipix*) ac_cv_func_calloc_0_nonnull="guessing yes" ;; - # Guess yes on native Windows. - mingw* | windows*) ac_cv_func_calloc_0_nonnull="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) ac_cv_func_calloc_0_nonnull="$gl_cross_guess_normal" ;; - esac - fi - ]) - AS_CASE([$ac_cv_func_calloc_0_nonnull], [*yes], [$1], [$2]) -]) -m4trace:gnulib-m4/calloc.m4:57: -1- AC_DEFUN([gl_FUNC_CALLOC_GNU], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_CALLOC_POSIX]) - REPLACE_CALLOC_FOR_CALLOC_GNU="$REPLACE_CALLOC_FOR_CALLOC_POSIX" - if test $REPLACE_CALLOC_FOR_CALLOC_GNU = 0; then - _AC_FUNC_CALLOC_IF([], [REPLACE_CALLOC_FOR_CALLOC_GNU=1]) - fi -]) -m4trace:gnulib-m4/calloc.m4:72: -1- AC_DEFUN([gl_FUNC_CALLOC_POSIX], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) - if test $REPLACE_MALLOC_FOR_MALLOC_POSIX = 1; then - REPLACE_CALLOC_FOR_CALLOC_POSIX=1 - fi - dnl Although in theory we should also test for size_t overflow, - dnl in practice testing for ptrdiff_t overflow suffices - dnl since PTRDIFF_MAX <= SIZE_MAX on all known Gnulib porting targets. - dnl A separate size_t test would slow down 'configure'. -]) -m4trace:gnulib-m4/canonicalize.m4:11: -1- AC_DEFUN([gl_FUNC_CANONICALIZE_FILENAME_MODE], [ - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_REQUIRE([gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK]) - AC_CHECK_FUNCS_ONCE([canonicalize_file_name]) - gl_CHECK_FUNCS_ANDROID([faccessat], [[#include ]]) - AC_REQUIRE([gl_DOUBLE_SLASH_ROOT]) - AC_REQUIRE([gl_FUNC_REALPATH_WORKS]) - if test $ac_cv_func_canonicalize_file_name = no; then - HAVE_CANONICALIZE_FILE_NAME=0 - else - case "$gl_cv_func_realpath_works" in - *yes) ;; - *) REPLACE_CANONICALIZE_FILE_NAME=1 ;; - esac - fi -]) -m4trace:gnulib-m4/canonicalize.m4:30: -1- AC_DEFUN([gl_CANONICALIZE_LGPL], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_CANONICALIZE_LGPL_SEPARATE]) - if test $ac_cv_func_canonicalize_file_name = no; then - HAVE_CANONICALIZE_FILE_NAME=0 - if test $ac_cv_func_realpath = no; then - HAVE_REALPATH=0 - else - case "$gl_cv_func_realpath_works" in - *yes) ;; - *) REPLACE_REALPATH=1 ;; - esac - fi - else - case "$gl_cv_func_realpath_works" in - *yes) - ;; - *) - REPLACE_CANONICALIZE_FILE_NAME=1 - REPLACE_REALPATH=1 - ;; - esac - fi -]) -m4trace:gnulib-m4/canonicalize.m4:58: -1- AC_DEFUN([gl_CANONICALIZE_LGPL_SEPARATE], [ - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_REQUIRE([gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK]) - AC_CHECK_FUNCS_ONCE([canonicalize_file_name]) - gl_CHECK_FUNCS_ANDROID([faccessat], [[#include ]]) - - dnl On native Windows, we use _getcwd(), regardless whether getcwd() is - dnl available through the linker option '-loldnames'. - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - mingw* | windows*) ;; - *) AC_CHECK_FUNCS([getcwd]) ;; - esac - - AC_REQUIRE([gl_DOUBLE_SLASH_ROOT]) - AC_REQUIRE([gl_FUNC_REALPATH_WORKS]) - AC_CHECK_HEADERS_ONCE([sys/param.h]) -]) -m4trace:gnulib-m4/canonicalize.m4:81: -1- AC_DEFUN([gl_FUNC_REALPATH_WORKS], [ - AC_CHECK_FUNCS_ONCE([realpath lstat]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether realpath works], [gl_cv_func_realpath_works], [ - rm -rf conftest.a conftest.d - touch conftest.a - # Assume that if we have lstat, we can also check symlinks. - if test $ac_cv_func_lstat = yes; then - ln -s conftest.a conftest.l - fi - mkdir conftest.d - AC_RUN_IFELSE([ - AC_LANG_PROGRAM([[ - ]GL_NOCRASH[ - #include - #include - #include - ]], [[ - int result = 0; - /* This test fails on Solaris 10. */ - { - char *name = realpath ("conftest.a", NULL); - if (!(name && *name == '/')) - result |= 1; - free (name); - } - /* This test fails on older versions of Cygwin. */ - { - char *name = realpath ("conftest.b/../conftest.a", NULL); - if (name != NULL) - result |= 2; - free (name); - } - /* This test fails on Cygwin 2.9. */ - #if HAVE_LSTAT - { - char *name = realpath ("conftest.l/../conftest.a", NULL); - if (name != NULL || errno != ENOTDIR) - result |= 4; - free (name); - } - #endif - /* This test fails on Mac OS X 10.13, OpenBSD 6.0. */ - { - char *name = realpath ("conftest.a/", NULL); - if (name != NULL) - result |= 8; - free (name); - } - /* This test fails on AIX 7, Solaris 10. */ - { - char *name1 = realpath (".", NULL); - char *name2 = realpath ("conftest.d//./..", NULL); - if (! name1 || ! name2 || strcmp (name1, name2)) - result |= 16; - free (name1); - free (name2); - } - #ifdef __linux__ - /* On Linux, // is the same as /. See also double-slash-root.m4. - realpath() should respect this. - This test fails on musl libc 1.2.2. */ - { - char *name = realpath ("//", NULL); - if (! name || strcmp (name, "/")) - result |= 32; - free (name); - } - #endif - return result; - ]]) - ], - [gl_cv_func_realpath_works=yes], - [case $? in - 32) gl_cv_func_realpath_works=nearly ;; - *) gl_cv_func_realpath_works=no ;; - esac - ], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_realpath_works="guessing yes" ;; - # Guess 'nearly' on musl systems. - *-musl*) gl_cv_func_realpath_works="guessing nearly" ;; - # Guess no on Cygwin. - cygwin*) gl_cv_func_realpath_works="guessing no" ;; - # Guess no on native Windows. - mingw* | windows*) gl_cv_func_realpath_works="guessing no" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_realpath_works="$gl_cross_guess_normal" ;; - esac - ]) - rm -rf conftest.a conftest.l conftest.d - ]) - case "$gl_cv_func_realpath_works" in - *yes) - AC_DEFINE([FUNC_REALPATH_WORKS], [1], - [Define to 1 if realpath() can malloc memory, always gives an absolute path, and handles leading slashes and a trailing slash correctly.]) - ;; - *nearly) - AC_DEFINE([FUNC_REALPATH_NEARLY_WORKS], [1], - [Define to 1 if realpath() can malloc memory, always gives an absolute path, and handles a trailing slash correctly.]) - ;; - esac -]) -m4trace:gnulib-m4/close.m4:7: -1- AC_DEFUN_ONCE([gl_FUNC_CLOSE], [ - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - m4_ifdef([gl_MSVC_INVAL], [ - AC_REQUIRE([gl_MSVC_INVAL]) - if test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1; then - REPLACE_CLOSE=1 - fi - ]) - m4_ifdef([gl_PREREQ_SYS_H_WINSOCK2], [ - gl_PREREQ_SYS_H_WINSOCK2 - if test $UNISTD_H_HAVE_WINSOCK2_H = 1; then - dnl Even if the 'socket' module is not used here, another part of the - dnl application may use it and pass file descriptors that refer to - dnl sockets to the close() function. So enable the support for sockets. - REPLACE_CLOSE=1 - fi - ]) - dnl Replace close() for supporting the gnulib-defined fchdir() function, - dnl to keep fchdir's bookkeeping up-to-date. - m4_ifdef([gl_FUNC_FCHDIR], [ - if test $REPLACE_CLOSE = 0; then - gl_TEST_FCHDIR - if test $HAVE_FCHDIR = 0; then - REPLACE_CLOSE=1 - fi - fi - ]) -]) -m4trace:gnulib-m4/codeset.m4:10: -1- AC_DEFUN([AM_LANGINFO_CODESET], [ - AC_CACHE_CHECK([for nl_langinfo and CODESET], [am_cv_langinfo_codeset], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[char* cs = nl_langinfo(CODESET); return !cs;]])], - [am_cv_langinfo_codeset=yes], - [am_cv_langinfo_codeset=no]) - ]) - if test $am_cv_langinfo_codeset = yes; then - AC_DEFINE([HAVE_LANGINFO_CODESET], [1], - [Define if you have and nl_langinfo(CODESET).]) - fi -]) -m4trace:gnulib-m4/csharp.m4:9: -1- AC_DEFUN([gt_CSHARP_CHOICE], [ - AC_MSG_CHECKING([for preferred C[#] implementation]) - AC_ARG_ENABLE([csharp], - [ --enable-csharp[[=IMPL]] choose preferred C[#] implementation (mono)], - [CSHARP_CHOICE="$enableval"], - CSHARP_CHOICE=any) - AC_SUBST([CSHARP_CHOICE]) - AC_MSG_RESULT([$CSHARP_CHOICE]) - case "$CSHARP_CHOICE" in - mono) - AC_DEFINE([CSHARP_CHOICE_MONO], [1], - [Define if mono is the preferred C# implementation.]) - ;; - esac -]) -m4trace:gnulib-m4/csharpcomp.m4:12: -1- AC_DEFUN([gt_CSHARPCOMP], [ - AC_REQUIRE([gt_CSHARP_CHOICE]) - AC_MSG_CHECKING([for C[#] compiler]) - HAVE_CSHARPCOMP=1 - pushdef([AC_MSG_CHECKING],[:])dnl - pushdef([AC_CHECKING],[:])dnl - pushdef([AC_MSG_RESULT],[:])dnl - AC_CHECK_PROG([HAVE_MCS_IN_PATH], [mcs], [yes]) - AC_CHECK_PROG([HAVE_CSC_IN_PATH], [csc], [yes]) - popdef([AC_MSG_RESULT])dnl - popdef([AC_CHECKING])dnl - popdef([AC_MSG_CHECKING])dnl - for impl in "$CSHARP_CHOICE" mono sscli no; do - case "$impl" in - mono) - if test -n "$HAVE_MCS_IN_PATH" \ - && mcs --version >/dev/null 2>/dev/null \ - && mcs --version 2>/dev/null | grep Mono >/dev/null; then - HAVE_MCS=1 - ac_result="mcs" - break - fi - ;; - sscli) - if test -n "$HAVE_CSC_IN_PATH" \ - && csc -help >/dev/null 2>/dev/null \ - && { if csc -help 2>/dev/null | grep -i chicken > /dev/null; then false; else true; fi; }; then - HAVE_CSC=1 - ac_result="csc" - break - fi - ;; - no) - HAVE_CSHARPCOMP= - ac_result="no" - break - ;; - esac - done - AC_MSG_RESULT([$ac_result]) - AC_SUBST([HAVE_MCS]) - AC_SUBST([HAVE_CSC]) - dnl Provide a default for CSHARPCOMPFLAGS. - if test -z "${CSHARPCOMPFLAGS+set}"; then - CSHARPCOMPFLAGS="-O -g" - fi - AC_SUBST([CSHARPCOMPFLAGS]) -]) -m4trace:gnulib-m4/double-slash-root.m4:7: -1- AC_DEFUN([gl_DOUBLE_SLASH_ROOT], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether // is distinct from /], [gl_cv_double_slash_root], - [ if test x"$cross_compiling" = xyes ; then - # When cross-compiling, there is no way to tell whether // is special - # short of a list of hosts. However, the only known hosts to date - # that have a distinct // are Apollo DomainOS (too old to port to), - # Cygwin, and z/OS. If anyone knows of another system for which // has - # special semantics and is distinct from /, please report it to - # . - case $host in - *-cygwin | i370-ibm-openedition) - gl_cv_double_slash_root=yes ;; - *) - # Be optimistic and assume that / and // are the same when we - # don't know. - gl_cv_double_slash_root='unknown, assuming no' ;; - esac - else - set x `ls -di / // 2>/dev/null` - if test "$[2]" = "$[4]" && wc //dev/null >/dev/null 2>&1; then - gl_cv_double_slash_root=no - else - gl_cv_double_slash_root=yes - fi - fi]) - if test "$gl_cv_double_slash_root" = yes; then - AC_DEFINE([DOUBLE_SLASH_IS_DISTINCT_ROOT], [1], - [Define to 1 if // is a file system root distinct from /.]) - fi -]) -m4trace:gnulib-m4/dup2.m4:7: -1- AC_DEFUN([gl_FUNC_DUP2], [ - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether dup2 works], [gl_cv_func_dup2_works], - [AC_RUN_IFELSE([ - AC_LANG_PROGRAM( - [[#include - #include - #include - #include - #include - ]GL_MDA_DEFINES[ - #ifndef RLIM_SAVED_CUR - # define RLIM_SAVED_CUR RLIM_INFINITY - #endif - #ifndef RLIM_SAVED_MAX - # define RLIM_SAVED_MAX RLIM_INFINITY - #endif - ]], - [[int result = 0; - int bad_fd = INT_MAX; - struct rlimit rlim; - if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 - && 0 <= rlim.rlim_cur && rlim.rlim_cur <= INT_MAX - && rlim.rlim_cur != RLIM_INFINITY - && rlim.rlim_cur != RLIM_SAVED_MAX - && rlim.rlim_cur != RLIM_SAVED_CUR) - bad_fd = rlim.rlim_cur; - #ifdef FD_CLOEXEC - if (fcntl (1, F_SETFD, FD_CLOEXEC) == -1) - result |= 1; - #endif - if (dup2 (1, 1) != 1) - result |= 2; - #ifdef FD_CLOEXEC - if (fcntl (1, F_GETFD) != FD_CLOEXEC) - result |= 4; - #endif - close (0); - if (dup2 (0, 0) != -1) - result |= 8; - /* Many gnulib modules require POSIX conformance of EBADF. */ - if (dup2 (2, bad_fd) == -1 && errno != EBADF) - result |= 16; - /* Flush out some cygwin core dumps. */ - if (dup2 (2, -1) != -1 || errno != EBADF) - result |= 32; - dup2 (2, 255); - dup2 (2, 256); - /* On OS/2 kLIBC, dup2() does not work on a directory fd. */ - { - int fd = open (".", O_RDONLY); - if (fd == -1) - result |= 64; - else if (dup2 (fd, fd + 1) == -1) - result |= 128; - close (fd); - } - return result;]]) - ], - [gl_cv_func_dup2_works=yes], [gl_cv_func_dup2_works=no], - [case "$host_os" in - mingw* | windows*) # on this platform, dup2 always returns 0 for success - gl_cv_func_dup2_works="guessing no" ;; - cygwin*) # on cygwin 1.5.x, dup2(1,1) returns 0 - gl_cv_func_dup2_works="guessing no" ;; - aix* | freebsd*) - # on AIX 7.1 and FreeBSD 6.1, dup2 (1,toobig) gives EMFILE, - # not EBADF. - gl_cv_func_dup2_works="guessing no" ;; - haiku*) # on Haiku alpha 2, dup2(1, 1) resets FD_CLOEXEC. - gl_cv_func_dup2_works="guessing no" ;; - *-android*) # implemented using dup3(), which fails if oldfd == newfd - gl_cv_func_dup2_works="guessing no" ;; - os2*) # on OS/2 kLIBC, dup2() does not work on a directory fd. - gl_cv_func_dup2_works="guessing no" ;; - *) gl_cv_func_dup2_works="guessing yes" ;; - esac]) - ]) - case "$gl_cv_func_dup2_works" in - *yes) ;; - *) - REPLACE_DUP2=1 - AC_CHECK_FUNCS([setdtablesize]) - ;; - esac - dnl Replace dup2() for supporting the gnulib-defined fchdir() function, - dnl to keep fchdir's bookkeeping up-to-date. - m4_ifdef([gl_FUNC_FCHDIR], [ - gl_TEST_FCHDIR - if test $HAVE_FCHDIR = 0; then - REPLACE_DUP2=1 - fi - ]) -]) -m4trace:gnulib-m4/dup2.m4:105: -1- AC_DEFUN([gl_PREREQ_DUP2], []) -m4trace:gnulib-m4/eealloc.m4:7: -1- AC_DEFUN([gl_EEALLOC], [ - AC_REQUIRE([gl_EEMALLOC]) - AC_REQUIRE([gl_EEREALLOC]) -]) -m4trace:gnulib-m4/eealloc.m4:13: -1- AC_DEFUN([gl_EEMALLOC], [ - _AC_FUNC_MALLOC_IF( - [gl_cv_func_malloc_0_nonnull=1], - [gl_cv_func_malloc_0_nonnull=0]) - AC_DEFINE_UNQUOTED([MALLOC_0_IS_NONNULL], [$gl_cv_func_malloc_0_nonnull], - [If malloc(0) is != NULL, define this to 1. Otherwise define this - to 0.]) -]) -m4trace:gnulib-m4/eealloc.m4:23: -1- AC_DEFUN([gl_EEREALLOC], [ - _AC_FUNC_REALLOC_IF( - [gl_cv_func_realloc_0_nonnull=1], - [gl_cv_func_realloc_0_nonnull=0]) - AC_DEFINE_UNQUOTED([REALLOC_0_IS_NONNULL], [$gl_cv_func_realloc_0_nonnull], - [If realloc(NULL,0) is != NULL, define this to 1. Otherwise define this - to 0.]) -]) -m4trace:gnulib-m4/environ.m4:7: -1- AC_DEFUN_ONCE([gl_ENVIRON], [ - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - dnl Persuade glibc to declare environ. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - AC_CHECK_HEADERS_ONCE([unistd.h]) - gt_CHECK_VAR_DECL( - [#if HAVE_UNISTD_H - #include - #endif - /* mingw, BeOS, Haiku declare environ in , not in . */ - #include - ], - [environ]) - if test $gt_cv_var_environ_declaration != yes; then - HAVE_DECL_ENVIRON=0 - fi -]) -m4trace:gnulib-m4/environ.m4:29: -1- AC_DEFUN([gt_CHECK_VAR_DECL], [ - define([gt_cv_var], [gt_cv_var_]$2[_declaration]) - AC_CACHE_CHECK([if $2 is properly declared], [gt_cv_var], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[$1 - typedef struct { int foo; } foo_t; - extern foo_t $2;]], - [[$2.foo = 1;]])], - [gt_cv_var=no], - [gt_cv_var=yes])]) - if test $gt_cv_var = yes; then - AC_DEFINE([HAVE_]m4_translit($2, [a-z], [A-Z])[_DECL], 1, - [Define if you have the declaration of $2.]) - fi - undefine([gt_cv_var]) -]) -m4trace:gnulib-m4/errno_h.m4:9: -1- AC_DEFUN_ONCE([gl_HEADER_ERRNO_H], [ - AC_REQUIRE([AC_PROG_CC]) - AC_CACHE_CHECK([for complete errno.h], [gl_cv_header_errno_h_complete], [ - AC_EGREP_CPP([booboo],[ -#include -#if !defined ETXTBSY -booboo +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# undef _GNU_SOURCE #endif -#if !defined ENOMSG -booboo +/* Enable X/Open compliant socket functions that do not require linking + with -lxnet on HP-UX 11.11. */ +#ifndef _HPUX_ALT_XOPEN_SOCKET_API +# undef _HPUX_ALT_XOPEN_SOCKET_API #endif -#if !defined EIDRM -booboo +/* Identify the host operating system as Minix. + This macro does not affect the system headers\' behavior. + A future release of Autoconf may stop defining this macro. */ +#ifndef _MINIX +# undef _MINIX #endif -#if !defined ENOLINK -booboo +/* Enable general extensions on NetBSD. + Enable NetBSD compatibility extensions on Minix. */ +#ifndef _NETBSD_SOURCE +# undef _NETBSD_SOURCE #endif -#if !defined EPROTO -booboo +/* Enable OpenBSD compatibility extensions on NetBSD. + Oddly enough, this does nothing on OpenBSD. */ +#ifndef _OPENBSD_SOURCE +# undef _OPENBSD_SOURCE #endif -#if !defined EMULTIHOP -booboo +/* Define to 1 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_SOURCE +# undef _POSIX_SOURCE #endif -#if !defined EBADMSG -booboo +/* Define to 2 if needed for POSIX-compatible behavior. */ +#ifndef _POSIX_1_SOURCE +# undef _POSIX_1_SOURCE #endif -#if !defined EOVERFLOW -booboo +/* Enable POSIX-compatible threading on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# undef _POSIX_PTHREAD_SEMANTICS #endif -#if !defined ENOTSUP -booboo +/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */ +#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ +# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ #endif -#if !defined ENETRESET -booboo +/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */ +#ifndef __STDC_WANT_IEC_60559_BFP_EXT__ +# undef __STDC_WANT_IEC_60559_BFP_EXT__ #endif -#if !defined ECONNABORTED -booboo +/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */ +#ifndef __STDC_WANT_IEC_60559_DFP_EXT__ +# undef __STDC_WANT_IEC_60559_DFP_EXT__ #endif -#if !defined ESTALE -booboo +/* Enable extensions specified by C23 Annex F. */ +#ifndef __STDC_WANT_IEC_60559_EXT__ +# undef __STDC_WANT_IEC_60559_EXT__ #endif -#if !defined EDQUOT -booboo +/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */ +#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__ +# undef __STDC_WANT_IEC_60559_FUNCS_EXT__ #endif -#if !defined ECANCELED -booboo +/* Enable extensions specified by C23 Annex H and ISO/IEC TS 18661-3:2015. */ +#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__ +# undef __STDC_WANT_IEC_60559_TYPES_EXT__ #endif -#if !defined EOWNERDEAD -booboo +/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */ +#ifndef __STDC_WANT_LIB_EXT2__ +# undef __STDC_WANT_LIB_EXT2__ #endif -#if !defined ENOTRECOVERABLE -booboo +/* Enable extensions specified by ISO/IEC 24747:2009. */ +#ifndef __STDC_WANT_MATH_SPEC_FUNCS__ +# undef __STDC_WANT_MATH_SPEC_FUNCS__ #endif -#if !defined EILSEQ -booboo +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# undef _TANDEM_SOURCE #endif - ], - [gl_cv_header_errno_h_complete=no], - [gl_cv_header_errno_h_complete=yes]) - ]) - if test $gl_cv_header_errno_h_complete = yes; then - GL_GENERATE_ERRNO_H=false - else - gl_NEXT_HEADERS([errno.h]) - GL_GENERATE_ERRNO_H=true - fi - gl_REPLACE_ERRNO_VALUE([EMULTIHOP]) - gl_REPLACE_ERRNO_VALUE([ENOLINK]) - gl_REPLACE_ERRNO_VALUE([EOVERFLOW]) -]) -m4trace:gnulib-m4/errno_h.m4:87: -1- AC_DEFUN([gl_REPLACE_ERRNO_VALUE], [ - if $GL_GENERATE_ERRNO_H; then - AC_CACHE_CHECK([for ]$1[ value], [gl_cv_header_errno_h_]$1, [ - AC_EGREP_CPP([yes],[ -#include -#ifdef ]$1[ -yes +/* Enable X/Open extensions. Define to 500 only if necessary + to make mbstate_t available. */ +#ifndef _XOPEN_SOURCE +# undef _XOPEN_SOURCE #endif - ], - [gl_cv_header_errno_h_]$1[=yes], - [gl_cv_header_errno_h_]$1[=no]) - if test $gl_cv_header_errno_h_]$1[ = no; then - AC_EGREP_CPP([yes],[ -#define _XOPEN_SOURCE_EXTENDED 1 -#include -#ifdef ]$1[ -yes +]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_STDIO_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDIO_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_STDLIB_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDLIB_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_STRING_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STRING_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_INTTYPES_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_STDINT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDINT_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_STRINGS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STRINGS_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_SYS_STAT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_STAT_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_SYS_TYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TYPES_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([STDC_HEADERS]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^STDC_HEADERS$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([STDC_HEADERS], [/* Define to 1 if all of the C89 standard headers exist (not just the ones + required in a freestanding environment). This macro is provided for + backward compatibility; new code need not use it. */ +@%:@undef STDC_HEADERS]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_WCHAR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WCHAR_H]) +m4trace:configure.ac:73: -1- AH_OUTPUT([HAVE_MINIX_CONFIG_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_MINIX_CONFIG_H]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_ALL_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_ALL_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_COSMO_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_COSMO_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_DARWIN_C_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_DARWIN_C_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_GNU_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_GNU_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_HPUX_ALT_XOPEN_SOCKET_API]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_HPUX_ALT_XOPEN_SOCKET_API$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_NETBSD_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_NETBSD_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_OPENBSD_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_OPENBSD_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_POSIX_PTHREAD_SEMANTICS]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_POSIX_PTHREAD_SEMANTICS$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_ATTRIBS_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_ATTRIBS_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_BFP_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_BFP_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_DFP_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_DFP_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_FUNCS_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_FUNCS_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_IEC_60559_TYPES_EXT__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_IEC_60559_TYPES_EXT__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_LIB_EXT2__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_LIB_EXT2__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__STDC_WANT_MATH_SPEC_FUNCS__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__STDC_WANT_MATH_SPEC_FUNCS__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_TANDEM_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_TANDEM_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_MINIX]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_MINIX$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_POSIX_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_POSIX_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_POSIX_1_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_POSIX_1_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__EXTENSIONS__]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__EXTENSIONS__$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_XOPEN_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_XOPEN_SOURCE$]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_ISOC11_SOURCE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_ISOC11_SOURCE$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([_ISOC11_SOURCE], [/* Define to enable the declarations of ISO C 11 types and functions. */ +@%:@undef _ISOC11_SOURCE]) +m4trace:configure.ac:73: -1- AC_SUBST([CXX_CHOICE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXX_CHOICE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXX_CHOICE$]) +m4trace:configure.ac:73: -1- AC_SUBST([CXX]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXX]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:73: -1- AC_SUBST([ac_ct_CXX]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([ac_ct_CXX]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^ac_ct_CXX$]) +m4trace:configure.ac:73: -1- AC_SUBST([CXX]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXX]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:73: -1- AC_SUBST([CXXFLAGS]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXXFLAGS]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXXFLAGS$]) +m4trace:configure.ac:73: -1- AC_SUBST([CXX]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXX]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:73: -1- AM_CONDITIONAL([ANSICXX], [test "$CXX" != no]) +m4trace:configure.ac:73: -1- AC_SUBST([ANSICXX_TRUE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([ANSICXX_TRUE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^ANSICXX_TRUE$]) +m4trace:configure.ac:73: -1- AC_SUBST([ANSICXX_FALSE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([ANSICXX_FALSE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^ANSICXX_FALSE$]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([ANSICXX_TRUE]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([ANSICXX_FALSE]) +m4trace:configure.ac:73: -1- AC_SUBST([CXXDEPMODE], [depmode=$am_cv_CXX_dependencies_compiler_type]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([CXXDEPMODE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^CXXDEPMODE$]) +m4trace:configure.ac:73: -1- AM_CONDITIONAL([am__fastdepCXX], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3]) +m4trace:configure.ac:73: -1- AC_SUBST([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^am__fastdepCXX_TRUE$]) +m4trace:configure.ac:73: -1- AC_SUBST([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^am__fastdepCXX_FALSE$]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- AM_CONDITIONAL([am__fastdepCXX], [false]) +m4trace:configure.ac:73: -1- AC_SUBST([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^am__fastdepCXX_TRUE$]) +m4trace:configure.ac:73: -1- AC_SUBST([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- AC_SUBST_TRACE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^am__fastdepCXX_FALSE$]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_TRUE]) +m4trace:configure.ac:73: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_FILE_OFFSET_BITS]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_FILE_OFFSET_BITS$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([_FILE_OFFSET_BITS], [/* Number of bits in a file offset, on hosts where this is settable. */ +@%:@undef _FILE_OFFSET_BITS]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_LARGE_FILES]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_LARGE_FILES$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([_LARGE_FILES], [/* Define to 1 on platforms where this makes off_t a 64-bit type. */ +@%:@undef _LARGE_FILES]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([_TIME_BITS]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^_TIME_BITS$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([_TIME_BITS], [/* Number of bits in time_t, on hosts where this is settable. */ +@%:@undef _TIME_BITS]) +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__MINGW_USE_VC2005_COMPAT]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__MINGW_USE_VC2005_COMPAT$]) +m4trace:configure.ac:73: -1- AH_OUTPUT([__MINGW_USE_VC2005_COMPAT], [/* Define to 1 on platforms where this makes time_t a 64-bit type. */ +@%:@undef __MINGW_USE_VC2005_COMPAT]) +m4trace:configure.ac:73: -1- AH_OUTPUT([MINGW_ANSI_STDIO], [/* Use GNU style printf and scanf. */ +#ifndef __USE_MINGW_ANSI_STDIO +# undef __USE_MINGW_ANSI_STDIO #endif - ], [gl_cv_header_errno_h_]$1[=hidden]) - if test $gl_cv_header_errno_h_]$1[ = hidden; then - dnl The macro exists but is hidden. - dnl Define it to the same value. - AC_COMPUTE_INT([gl_cv_header_errno_h_]$1, $1, [ -#define _XOPEN_SOURCE_EXTENDED 1 -#include -/* The following two lines are a workaround against an autoconf-2.52 bug. */ -#include -#include ]) - fi - fi - ]) - case $gl_cv_header_errno_h_$1 in - yes | no) - $1_HIDDEN=0; $1_VALUE= - ;; - *) - $1_HIDDEN=1; $1_VALUE="$gl_cv_header_errno_h_$1" - ;; - esac - AC_SUBST($1[_HIDDEN]) - AC_SUBST($1[_VALUE]) - fi -]) -m4trace:gnulib-m4/error.m4:9: -1- AC_DEFUN([gl_ERROR], [ -]) -m4trace:gnulib-m4/error.m4:14: -1- AC_DEFUN([gl_PREREQ_ERROR], [ - dnl Use system extensions on Android, so that AC_FUNC_STRERROR_R - dnl discovers the GNU API for strerror_r on Android API level 23 and later. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - AC_REQUIRE([AC_FUNC_STRERROR_R]) - : -]) -m4trace:gnulib-m4/error_h.m4:10: -1- AC_DEFUN_ONCE([gl_ERROR_H], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - gl_CHECK_NEXT_HEADERS([error.h]) - if test $ac_cv_header_error_h = yes; then - HAVE_ERROR_H=1 - else - HAVE_ERROR_H=0 - fi - AC_SUBST([HAVE_ERROR_H]) - - REPLACE_ERROR=0 - - gl_CHECK_FUNCS_ANDROID([error], [[#include ]]) - if test $ac_cv_func_error = yes; then - HAVE_ERROR=1 - else - HAVE_ERROR=0 - case "$gl_cv_onwards_func_error" in - future*) REPLACE_ERROR=1 ;; - esac - fi - - dnl We don't use AC_FUNC_ERROR_AT_LINE any more, because it is no longer - dnl maintained in Autoconf and because it invokes AC_LIBOBJ. - dnl We need to notice a missing declaration, like gl_CHECK_FUNCS_ANDROID does. - AC_CHECK_DECL([error_at_line], , , [[#include ]]) - if test $ac_cv_have_decl_error_at_line = yes; then - AC_CACHE_CHECK([for error_at_line], [ac_cv_lib_error_at_line], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[error_at_line (0, 0, "", 0, "an error occurred");]])], - [ac_cv_lib_error_at_line=yes], - [ac_cv_lib_error_at_line=no])]) - else - ac_cv_lib_error_at_line=no - fi - if test $ac_cv_lib_error_at_line = yes; then - HAVE_ERROR_AT_LINE=1 - else - HAVE_ERROR_AT_LINE=0 - fi - REPLACE_ERROR_AT_LINE=0 - - if test $ac_cv_func_error = yes && test $ac_cv_lib_error_at_line = yes; then - dnl On Android 11, when error_print_progname is set, the output of the - dnl error() function contains an extra space. - AC_CACHE_CHECK([for working error function], - [gl_cv_func_working_error], - [if test $cross_compiling != yes; then - AC_LINK_IFELSE( - [AC_LANG_PROGRAM([[ - #include - static void print_no_progname (void) {} - ]], [[ - error_print_progname = print_no_progname; - error (0, 0, "foo"); - ]]) - ], - [rm -f conftest.out - if test -s conftest$ac_exeext \ - && ./conftest$ac_exeext 2> conftest.out; then - if grep ' ' conftest.out >/dev/null; then - gl_cv_func_working_error=no - else - gl_cv_func_working_error=yes - fi - else - gl_cv_func_working_error=no - fi - rm -f conftest.out - ], - [gl_cv_func_working_error=no]) - else - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #include - ]], [[ - error (0, 0, "foo"); - ]]) - ], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_working_error="guessing yes" ;; - # Guess no on Android. - linux*-android*) gl_cv_func_working_error="guessing no" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_working_error="$gl_cross_guess_normal" ;; - esac - ], - [gl_cv_func_working_error=no]) - fi - ]) - case "$gl_cv_func_working_error" in - *no) - REPLACE_ERROR=1 - REPLACE_ERROR_AT_LINE=1 - ;; - esac - fi - - if test $HAVE_ERROR = 0 || test $REPLACE_ERROR = 1 \ - || test $HAVE_ERROR_AT_LINE = 0 || test $REPLACE_ERROR_AT_LINE = 1; then - COMPILE_ERROR_C=1 - else - COMPILE_ERROR_C=0 - fi - - AC_SUBST([HAVE_ERROR]) - AC_SUBST([HAVE_ERROR_AT_LINE]) - AC_SUBST([REPLACE_ERROR]) - AC_SUBST([REPLACE_ERROR_AT_LINE]) -]) -m4trace:gnulib-m4/extensions.m4:217: -1- AC_DEFUN_ONCE([gl_USE_SYSTEM_EXTENSIONS], [ - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - dnl On OpenBSD 6.8 with GCC, the include files contain a couple of - dnl definitions that are only activated with an explicit -D_ISOC11_SOURCE. - dnl That's because this version of GCC (4.2.1) supports the option - dnl '-std=gnu99' but not the option '-std=gnu11'. - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - openbsd*) - AC_DEFINE([_ISOC11_SOURCE], [1], - [Define to enable the declarations of ISO C 11 types and functions.]) - ;; - esac -]) -m4trace:gnulib-m4/extern-inline.m4:8: -1- AC_DEFUN([gl_EXTERN_INLINE], [ - AC_CACHE_CHECK([whether ctype.h defines __header_inline], - [gl_cv_have___header_inline], - [AC_PREPROC_IFELSE( - [AC_LANG_SOURCE([[#include - #ifndef __header_inline - #error " does not define __header_inline" - #endif - ]])], - [gl_cv_have___header_inline=yes], - [gl_cv_have___header_inline=no])]) - if test "$gl_cv_have___header_inline" = yes; then - AC_DEFINE([HAVE___HEADER_INLINE], [1], - [Define to 1 if ctype.h defines __header_inline.]) - fi - - AH_VERBATIM([HAVE___HEADER_INLINE_1], -[/* Please see the Gnulib manual for how to use these macros. - - Suppress extern inline with HP-UX cc, as it appears to be broken; see - . - - Suppress extern inline with Sun C in standards-conformance mode, as it - mishandles inline functions that call each other. E.g., for 'inline void f - (void) { } inline void g (void) { f (); }', c99 incorrectly complains - 'reference to static identifier "f" in extern inline function'. - This bug was observed with Oracle Developer Studio 12.6 - (Sun C 5.15 SunOS_sparc 2017/05/30). - - Suppress extern inline (with or without __attribute__ ((__gnu_inline__))) - on configurations that mistakenly use 'static inline' to implement - functions or macros in standard C headers like . For example, - if isdigit is mistakenly implemented via a static inline function, - a program containing an extern inline function that calls isdigit - may not work since the C standard prohibits extern inline functions - from calling static functions (ISO C 99 section 6.7.4.(3). - This bug is known to occur on: - - OS X 10.8 and earlier; see: - https://lists.gnu.org/r/bug-gnulib/2012-12/msg00023.html - - DragonFly; see - http://muscles.dragonflybsd.org/bulk/clang-master-potential/20141111_102002/logs/ah-tty-0.3.12.log - - FreeBSD; see: - https://lists.gnu.org/r/bug-gnulib/2014-07/msg00104.html - - OS X 10.9 has a macro __header_inline indicating the bug is fixed for C and - for clang but remains for g++; see . - Assume DragonFly and FreeBSD will be similar. - - GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 - inline semantics, unless -fgnu89-inline is used. It defines a macro - __GNUC_STDC_INLINE__ to indicate this situation or a macro - __GNUC_GNU_INLINE__ to indicate the opposite situation. - GCC 4.2 with -std=c99 or -std=gnu99 implements the GNU C inline - semantics but warns, unless -fgnu89-inline is used: - warning: C99 inline functions are not supported; using GNU89 - warning: to disable this warning use -fgnu89-inline or the gnu_inline function attribute - It defines a macro __GNUC_GNU_INLINE__ to indicate this situation. - */ -#if (((defined __APPLE__ && defined __MACH__) \ - || defined __DragonFly__ || defined __FreeBSD__) \ - && (defined HAVE___HEADER_INLINE \ - ? (defined __cplusplus && defined __GNUC_STDC_INLINE__ \ - && ! defined __clang__) \ - : ((! defined _DONT_USE_CTYPE_INLINE_ \ - && (defined __GNUC__ || defined __cplusplus)) \ - || (defined _FORTIFY_SOURCE && 0 < _FORTIFY_SOURCE \ - && defined __GNUC__ && ! defined __cplusplus)))) -# define _GL_EXTERN_INLINE_STDHEADER_BUG -#endif -#if ((__GNUC__ \ - ? (defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__ \ - && !defined __PCC__) \ - : (199901L <= __STDC_VERSION__ \ - && !defined __HP_cc \ - && !defined __PGI \ - && !(defined __SUNPRO_C && __STDC__))) \ - && !defined _GL_EXTERN_INLINE_STDHEADER_BUG) -# define _GL_INLINE inline -# define _GL_EXTERN_INLINE extern inline -# define _GL_EXTERN_INLINE_IN_USE -#elif (2 < __GNUC__ + (7 <= __GNUC_MINOR__) && !defined __STRICT_ANSI__ \ - && !defined __PCC__ \ - && !defined _GL_EXTERN_INLINE_STDHEADER_BUG) -# if defined __GNUC_GNU_INLINE__ && __GNUC_GNU_INLINE__ - /* __gnu_inline__ suppresses a GCC 4.2 diagnostic. */ -# define _GL_INLINE extern inline __attribute__ ((__gnu_inline__)) -# else -# define _GL_INLINE extern inline -# endif -# define _GL_EXTERN_INLINE extern -# define _GL_EXTERN_INLINE_IN_USE -#else -# define _GL_INLINE _GL_UNUSED static -# define _GL_EXTERN_INLINE _GL_UNUSED static -#endif - -/* In GCC 4.6 (inclusive) to 5.1 (exclusive), - suppress bogus "no previous prototype for 'FOO'" - and "no previous declaration for 'FOO'" diagnostics, - when FOO is an inline function in the header; see - and - . */ -#if __GNUC__ == 4 && 6 <= __GNUC_MINOR__ -# if defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__ -# define _GL_INLINE_HEADER_CONST_PRAGMA -# else -# define _GL_INLINE_HEADER_CONST_PRAGMA \ - _Pragma ("GCC diagnostic ignored \"-Wsuggest-attribute=const\"") -# endif -# define _GL_INLINE_HEADER_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wmissing-prototypes\"") \ - _Pragma ("GCC diagnostic ignored \"-Wmissing-declarations\"") \ - _GL_INLINE_HEADER_CONST_PRAGMA -# define _GL_INLINE_HEADER_END \ - _Pragma ("GCC diagnostic pop") -#else -# define _GL_INLINE_HEADER_BEGIN -# define _GL_INLINE_HEADER_END -#endif]) -]) -m4trace:gnulib-m4/fcntl.m4:16: -1- AC_DEFUN([gl_FUNC_FCNTL], [ - dnl Persuade glibc to expose F_DUPFD_CLOEXEC. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_REQUIRE([gl_FCNTL_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CHECK_FUNCS_ONCE([fcntl]) - if test $ac_cv_func_fcntl = no; then - gl_REPLACE_FCNTL - else - dnl cygwin 1.5.x F_DUPFD has wrong errno, and allows negative target - dnl haiku alpha 2 F_DUPFD has wrong errno - AC_CACHE_CHECK([whether fcntl handles F_DUPFD correctly], - [gl_cv_func_fcntl_f_dupfd_works], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #include - #include - #include - ]GL_MDA_DEFINES[ - #ifndef RLIM_SAVED_CUR - # define RLIM_SAVED_CUR RLIM_INFINITY - #endif - #ifndef RLIM_SAVED_MAX - # define RLIM_SAVED_MAX RLIM_INFINITY - #endif - ]], - [[int result = 0; - int bad_fd = INT_MAX; - struct rlimit rlim; - if (getrlimit (RLIMIT_NOFILE, &rlim) == 0 - && 0 <= rlim.rlim_cur && rlim.rlim_cur <= INT_MAX - && rlim.rlim_cur != RLIM_INFINITY - && rlim.rlim_cur != RLIM_SAVED_MAX - && rlim.rlim_cur != RLIM_SAVED_CUR) - bad_fd = rlim.rlim_cur; - if (fcntl (0, F_DUPFD, -1) != -1) result |= 1; - if (errno != EINVAL) result |= 2; - if (fcntl (0, F_DUPFD, bad_fd) != -1) result |= 4; - if (errno != EINVAL) result |= 8; - /* On OS/2 kLIBC, F_DUPFD does not work on a directory fd */ - { - int fd; - fd = open (".", O_RDONLY); - if (fd == -1) - result |= 16; - else if (fcntl (fd, F_DUPFD, STDERR_FILENO + 1) == -1) - result |= 32; - - close (fd); - } - return result;]])], - [gl_cv_func_fcntl_f_dupfd_works=yes], - [gl_cv_func_fcntl_f_dupfd_works=no], - [case $host_os in - aix* | cygwin* | haiku*) - gl_cv_func_fcntl_f_dupfd_works="guessing no" ;; - *) gl_cv_func_fcntl_f_dupfd_works="guessing yes" ;; - esac])]) - case $gl_cv_func_fcntl_f_dupfd_works in - *yes) ;; - *) gl_REPLACE_FCNTL - AC_DEFINE([FCNTL_DUPFD_BUGGY], [1], [Define this to 1 if F_DUPFD - behavior does not match POSIX]) ;; - esac - - dnl Many systems lack F_DUPFD_CLOEXEC. - dnl NetBSD 9.0 declares F_DUPFD_CLOEXEC but it works only like F_DUPFD. - AC_CACHE_CHECK([whether fcntl understands F_DUPFD_CLOEXEC], - [gl_cv_func_fcntl_f_dupfd_cloexec], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE( - [[#include - #include - int main (int argc, char *argv[]) - { - if (argc == 1) - /* parent process */ - { - if (fcntl (1, F_DUPFD_CLOEXEC, 10) < 0) - return 1; - return execl ("./conftest", "./conftest", "child", NULL); - } - else - /* child process */ - return (fcntl (10, F_GETFL) < 0 ? 0 : 42); - } - ]]) - ], - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ -#ifdef __linux__ -/* The Linux kernel only added F_DUPFD_CLOEXEC in 2.6.24, so we always replace - it to support the semantics on older kernels that failed with EINVAL. */ -choke me -#endif - ]])], - [gl_cv_func_fcntl_f_dupfd_cloexec=yes], - [gl_cv_func_fcntl_f_dupfd_cloexec="needs runtime check"]) - ], - [gl_cv_func_fcntl_f_dupfd_cloexec=no], - [case "$host_os" in - # Guess no on NetBSD. - netbsd*) gl_cv_func_fcntl_f_dupfd_cloexec="guessing no" ;; - *) gl_cv_func_fcntl_f_dupfd_cloexec="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_fcntl_f_dupfd_cloexec" in - *yes) ;; - *) gl_REPLACE_FCNTL - dnl No witness macro needed for this bug. - ;; - esac - fi - dnl Replace fcntl() for supporting the gnulib-defined fchdir() function, - dnl to keep fchdir's bookkeeping up-to-date. - m4_ifdef([gl_FUNC_FCHDIR], [ - gl_TEST_FCHDIR - if test $HAVE_FCHDIR = 0; then - gl_REPLACE_FCNTL - fi - ]) -]) -m4trace:gnulib-m4/fcntl.m4:142: -1- AC_DEFUN([gl_REPLACE_FCNTL], [ - AC_REQUIRE([gl_FCNTL_H_DEFAULTS]) - AC_CHECK_FUNCS_ONCE([fcntl]) - if test $ac_cv_func_fcntl = no; then - HAVE_FCNTL=0 - else - REPLACE_FCNTL=1 - fi -]) -m4trace:gnulib-m4/fcntl_h.m4:10: -1- AC_DEFUN_ONCE([gl_FCNTL_H], [ - AC_REQUIRE([gl_FCNTL_H_DEFAULTS]) - AC_REQUIRE([gl_FCNTL_O_FLAGS]) - gl_NEXT_HEADERS([fcntl.h]) - - dnl Ensure the type pid_t gets defined. - AC_REQUIRE([AC_TYPE_PID_T]) - - dnl Ensure the type mode_t gets defined. - AC_REQUIRE([AC_TYPE_MODE_T]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use, if it is not common - dnl enough to be declared everywhere. - gl_WARN_ON_USE_PREPARE([[#include - ]], [fcntl openat]) -]) -m4trace:gnulib-m4/fcntl_h.m4:33: -1- AC_DEFUN([gl_FCNTL_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_FCNTL_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/fcntl_h.m4:45: -1- AC_DEFUN([gl_FCNTL_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_FCNTL_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CREAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCNTL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NONBLOCKING]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OPEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OPENAT]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CREAT], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_OPEN], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_FCNTL_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_FCNTL_H_DEFAULTS]) -]) -m4trace:gnulib-m4/fcntl_h.m4:61: -1- AC_DEFUN([gl_FCNTL_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_FCNTL=1; AC_SUBST([HAVE_FCNTL]) - HAVE_OPENAT=1; AC_SUBST([HAVE_OPENAT]) - REPLACE_CREAT=0; AC_SUBST([REPLACE_CREAT]) - REPLACE_FCNTL=0; AC_SUBST([REPLACE_FCNTL]) - REPLACE_OPEN=0; AC_SUBST([REPLACE_OPEN]) - REPLACE_OPENAT=0; AC_SUBST([REPLACE_OPENAT]) -]) -m4trace:gnulib-m4/free.m4:9: -1- AC_DEFUN([gl_FUNC_FREE], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - - dnl In the next release of POSIX, free must preserve errno. - dnl https://www.austingroupbugs.net/view.php?id=385 - dnl https://sourceware.org/bugzilla/show_bug.cgi?id=17924 - dnl So far, we know of three platforms that do this: - dnl * glibc >= 2.33, thanks to the fix for this bug: - dnl - dnl * OpenBSD >= 4.5, thanks to this commit: - dnl - dnl * Solaris, because its malloc() implementation is based on brk(), - dnl not mmap(); hence its free() implementation makes no system calls. - dnl For other platforms, you can only be sure if they state it in their - dnl documentation, or by code inspection of the free() implementation in libc. - AC_CACHE_CHECK([whether free is known to preserve errno], - [gl_cv_func_free_preserves_errno], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[#if 2 < __GLIBC__ + (33 <= __GLIBC_MINOR__) - #elif defined __OpenBSD__ - #elif defined __sun - #else - #error "'free' is not known to preserve errno" - #endif - ]])], - [gl_cv_func_free_preserves_errno=yes], - [gl_cv_func_free_preserves_errno=no]) - ]) - - case $gl_cv_func_free_preserves_errno in - *yes) - AC_DEFINE([HAVE_FREE_POSIX], [1], - [Define if the 'free' function is guaranteed to preserve errno.]) - ;; - *) REPLACE_FREE=1 ;; - esac -]) -m4trace:gnulib-m4/free.m4:52: -1- AC_DEFUN([gl_PREREQ_FREE], [:]) -m4trace:gnulib-m4/fstat.m4:7: -1- AC_DEFUN([gl_FUNC_FSTAT], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_SYS_STAT_H_DEFAULTS]) - - case "$host_os" in - darwin* | mingw* | windows* | solaris*) - dnl macOS and Solaris stat can return a negative tv_nsec. - dnl On MinGW, the original stat() returns st_atime, st_mtime, - dnl st_ctime values that are affected by the time zone. - REPLACE_FSTAT=1 - ;; - esac - - dnl Replace fstat() for supporting the gnulib-defined open() on directories. - m4_ifdef([gl_FUNC_FCHDIR], [ - gl_TEST_FCHDIR - if test $HAVE_FCHDIR = 0; then - case "$gl_cv_func_open_directory_works" in - *yes) ;; - *) - REPLACE_FSTAT=1 - ;; - esac - fi - ]) -]) -m4trace:gnulib-m4/fstat.m4:36: -1- AC_DEFUN([gl_PREREQ_FSTAT], [ - AC_REQUIRE([gl_SYS_STAT_H]) - AC_REQUIRE([gl_PREREQ_STAT_W32]) - : -]) -m4trace:gnulib-m4/getdtablesize.m4:7: -1- AC_DEFUN([gl_FUNC_GETDTABLESIZE], [ - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CHECK_FUNCS_ONCE([getdtablesize]) - AC_CHECK_DECLS_ONCE([getdtablesize]) - if test $ac_cv_func_getdtablesize = yes && - test $ac_cv_have_decl_getdtablesize = yes; then - AC_CACHE_CHECK([whether getdtablesize works], - [gl_cv_func_getdtablesize_works], - [dnl There are two concepts: the "maximum possible file descriptor value + 1" - dnl and the "maximum number of open file descriptors in a process". - dnl Per SUSv2 and POSIX, getdtablesize() should return the first one. - dnl On most platforms, the first and the second concept are the same. - dnl On OpenVMS, however, they are different and getdtablesize() returns - dnl the second one; thus the test below fails. But we don't care - dnl because there's no good way to write a replacement getdtablesize(). - case "$host_os" in - vms*) gl_cv_func_getdtablesize_works="no (limitation)" ;; - *) - dnl Cygwin 1.7.25 automatically increases the RLIMIT_NOFILE soft - dnl limit up to an unchangeable hard limit; all other platforms - dnl correctly require setrlimit before getdtablesize() can report - dnl a larger value. - AC_RUN_IFELSE([ - AC_LANG_PROGRAM( - [[#include ] - GL_MDA_DEFINES - ], - [[int size = getdtablesize(); - if (dup2 (0, getdtablesize()) != -1) - return 1; - if (size != getdtablesize()) - return 2; - ]])], - [gl_cv_func_getdtablesize_works=yes], - [gl_cv_func_getdtablesize_works=no], - [case "$host_os" in - cygwin*) # on cygwin 1.5.25, getdtablesize() automatically grows - gl_cv_func_getdtablesize_works="guessing no" ;; - *) gl_cv_func_getdtablesize_works="guessing yes" ;; - esac - ]) - ;; - esac - ]) - case "$gl_cv_func_getdtablesize_works" in - *yes | "no (limitation)") ;; - *) REPLACE_GETDTABLESIZE=1 ;; - esac - else - HAVE_GETDTABLESIZE=0 - fi -]) -m4trace:gnulib-m4/getdtablesize.m4:63: -1- AC_DEFUN([gl_PREREQ_GETDTABLESIZE], [:]) -m4trace:gnulib-m4/getopt.m4:8: -1- AC_DEFUN([gl_FUNC_GETOPT_POSIX], [ - m4_divert_text([DEFAULTS], [gl_getopt_required=POSIX]) - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - AC_REQUIRE([gl_GETOPT_CHECK_HEADERS]) - dnl Other modules can request the gnulib implementation of the getopt - dnl functions unconditionally, by defining gl_REPLACE_GETOPT_ALWAYS. - dnl argp.m4 does this. - m4_ifdef([gl_REPLACE_GETOPT_ALWAYS], [ - REPLACE_GETOPT=1 - ], [ - REPLACE_GETOPT=0 - if test -n "$gl_replace_getopt"; then - REPLACE_GETOPT=1 - fi - ]) - GL_GENERATE_GETOPT_H=false - GL_GENERATE_GETOPT_CDEFS_H=false - if test $REPLACE_GETOPT = 1; then - dnl Arrange for getopt.h to be created. - gl_GETOPT_SUBSTITUTE_HEADER - fi -]) -m4trace:gnulib-m4/getopt.m4:35: -1- AC_DEFUN([gl_FUNC_GETOPT_GNU], [ - dnl Set the variable gl_getopt_required, so that all invocations of - dnl gl_GETOPT_CHECK_HEADERS in the scope of the current configure file - dnl will check for getopt with GNU extensions. - dnl This means that if one gnulib-tool invocation requests getopt-posix - dnl and another gnulib-tool invocation requests getopt-gnu, it is as if - dnl both had requested getopt-gnu. - m4_divert_text([INIT_PREPARE], [gl_getopt_required=GNU]) - - dnl No need to invoke gl_FUNC_GETOPT_POSIX here; this is automatically - dnl done through the module dependency getopt-gnu -> getopt-posix. -]) -m4trace:gnulib-m4/getopt.m4:50: -1- AC_DEFUN([gl_GETOPT_CHECK_HEADERS], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_REQUIRE([AC_PROG_AWK]) dnl for awk that supports ENVIRON - - dnl Persuade Solaris to declare optarg, optind, opterr, optopt. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - gl_CHECK_NEXT_HEADERS([getopt.h]) - if test $ac_cv_header_getopt_h = yes; then - HAVE_GETOPT_H=1 - else - HAVE_GETOPT_H=0 - fi - AC_SUBST([HAVE_GETOPT_H]) - - gl_replace_getopt= - - dnl Test whether is available. - if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then - AC_CHECK_HEADERS([getopt.h], [], [gl_replace_getopt=yes]) - fi - - dnl Test whether the function getopt_long is available. - if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then - AC_CHECK_FUNCS([getopt_long_only], [], [gl_replace_getopt=yes]) - fi - - dnl POSIX 2008 does not specify leading '+' behavior, but see - dnl http://austingroupbugs.net/view.php?id=191 for a recommendation on - dnl the next version of POSIX. For now, we only guarantee leading '+' - dnl behavior with getopt-gnu. - if test -z "$gl_replace_getopt"; then - AC_CACHE_CHECK([whether getopt is POSIX compatible], - [gl_cv_func_getopt_posix], - [ - dnl Merging these three different test programs into a single one - dnl would require a reset mechanism. On BSD systems, it can be done - dnl through 'optreset'; on some others (glibc), it can be done by - dnl setting 'optind' to 0; on others again (HP-UX, IRIX, OSF/1, - dnl Solaris 9, musl libc), there is no such mechanism. - if test $cross_compiling = no; then - dnl Sanity check. Succeeds everywhere (except on MSVC, - dnl which lacks and getopt() entirely). - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include - -int -main () -{ - static char program[] = "program"; - static char a[] = "-a"; - static char foo[] = "foo"; - static char bar[] = "bar"; - char *argv[] = { program, a, foo, bar, NULL }; - int c; - - c = getopt (4, argv, "ab"); - if (!(c == 'a')) - return 1; - c = getopt (4, argv, "ab"); - if (!(c == -1)) - return 2; - if (!(optind == 2)) - return 3; - return 0; -} -]])], - [gl_cv_func_getopt_posix=maybe], - [gl_cv_func_getopt_posix=no]) - if test $gl_cv_func_getopt_posix = maybe; then - dnl Sanity check with '+'. Succeeds everywhere (except on MSVC, - dnl which lacks and getopt() entirely). - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include - -int -main () -{ - static char program[] = "program"; - static char donald[] = "donald"; - static char p[] = "-p"; - static char billy[] = "billy"; - static char duck[] = "duck"; - static char a[] = "-a"; - static char bar[] = "bar"; - char *argv[] = { program, donald, p, billy, duck, a, bar, NULL }; - int c; - - c = getopt (7, argv, "+abp:q:"); - if (!(c == -1)) - return 4; - if (!(strcmp (argv[0], "program") == 0)) - return 5; - if (!(strcmp (argv[1], "donald") == 0)) - return 6; - if (!(strcmp (argv[2], "-p") == 0)) - return 7; - if (!(strcmp (argv[3], "billy") == 0)) - return 8; - if (!(strcmp (argv[4], "duck") == 0)) - return 9; - if (!(strcmp (argv[5], "-a") == 0)) - return 10; - if (!(strcmp (argv[6], "bar") == 0)) - return 11; - if (!(optind == 1)) - return 12; - return 0; -} -]])], - [gl_cv_func_getopt_posix=maybe], - [gl_cv_func_getopt_posix=no]) - fi - if test $gl_cv_func_getopt_posix = maybe; then - dnl Detect Mac OS X 10.5, AIX 7.1, mingw bug. - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include - -int -main () -{ - static char program[] = "program"; - static char ab[] = "-ab"; - char *argv[3] = { program, ab, NULL }; - if (getopt (2, argv, "ab:") != 'a') - return 13; - if (getopt (2, argv, "ab:") != '?') - return 14; - if (optopt != 'b') - return 15; - if (optind != 2) - return 16; - return 0; -} -]])], - [gl_cv_func_getopt_posix=yes], - [gl_cv_func_getopt_posix=no]) - fi - else - case "$host_os" in - darwin* | aix* | mingw* | windows*) gl_cv_func_getopt_posix="guessing no";; - *) gl_cv_func_getopt_posix="guessing yes";; - esac - fi - ]) - case "$gl_cv_func_getopt_posix" in - *no) gl_replace_getopt=yes ;; - esac - fi - - if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then - AC_CACHE_CHECK([for working GNU getopt function], [gl_cv_func_getopt_gnu], - [# Even with POSIXLY_CORRECT, the GNU extension of leading '-' in the - # optstring is necessary for programs like m4 that have POSIX-mandated - # semantics for supporting options interspersed with files. - # Also, since getopt_long is a GNU extension, we require optind=0. - # Bash ties 'set -o posix' to a non-exported POSIXLY_CORRECT; - # so take care to revert to the correct (non-)export state. -dnl GNU Coding Standards currently allow awk but not env; besides, env -dnl is ambiguous with environment values that contain newlines. - gl_awk_probe='BEGIN { if ("POSIXLY_CORRECT" in ENVIRON) print "x" }' - case ${POSIXLY_CORRECT+x}`$AWK "$gl_awk_probe" - #include - #include - ]GL_NOCRASH[ - ]], [[ - int result = 0; - - nocrash_init(); - - /* This code succeeds on glibc 2.8, OpenBSD 4.0, Cygwin, mingw, - and fails on Mac OS X 10.5, AIX 5.2, HP-UX 11, IRIX 6.5, - OSF/1 5.1, Solaris 10. */ - { - static char conftest[] = "conftest"; - static char plus[] = "-+"; - char *argv[3] = { conftest, plus, NULL }; - opterr = 0; - if (getopt (2, argv, "+a") != '?') - result |= 1; - } - /* This code succeeds on glibc 2.8, mingw, - and fails on Mac OS X 10.5, OpenBSD 4.0, AIX 5.2, HP-UX 11, - IRIX 6.5, OSF/1 5.1, Solaris 10, Cygwin 1.5.x. */ - { - static char program[] = "program"; - static char p[] = "-p"; - static char foo[] = "foo"; - static char bar[] = "bar"; - char *argv[] = { program, p, foo, bar, NULL }; - - optind = 1; - if (getopt (4, argv, "p::") != 'p') - result |= 2; - else if (optarg != NULL) - result |= 4; - else if (getopt (4, argv, "p::") != -1) - result |= 6; - else if (optind != 2) - result |= 8; - } - /* This code succeeds on glibc 2.8 and fails on Cygwin 1.7.0. */ - { - static char program[] = "program"; - static char foo[] = "foo"; - static char p[] = "-p"; - char *argv[] = { program, foo, p, NULL }; - optind = 0; - if (getopt (3, argv, "-p") != 1) - result |= 16; - else if (getopt (3, argv, "-p") != 'p') - result |= 16; - } - /* This code fails on glibc 2.11. */ - { - static char program[] = "program"; - static char b[] = "-b"; - static char a[] = "-a"; - char *argv[] = { program, b, a, NULL }; - optind = opterr = 0; - if (getopt (3, argv, "+:a:b") != 'b') - result |= 32; - else if (getopt (3, argv, "+:a:b") != ':') - result |= 32; - } - /* This code dumps core on glibc 2.14. */ - { - static char program[] = "program"; - static char w[] = "-W"; - static char dummy[] = "dummy"; - char *argv[] = { program, w, dummy, NULL }; - optind = opterr = 1; - if (getopt (3, argv, "W;") != 'W') - result |= 64; - } - return result; - ]])], - [gl_cv_func_getopt_gnu=yes], - [gl_cv_func_getopt_gnu=no], - [dnl Cross compiling. - dnl Assume the worst, even on glibc platforms. - dnl But obey --enable-cross-guesses. - gl_cv_func_getopt_gnu="$gl_cross_guess_normal" - ]) - case $gl_had_POSIXLY_CORRECT in - exported) ;; - yes) AS_UNSET([POSIXLY_CORRECT]); POSIXLY_CORRECT=1 ;; - *) AS_UNSET([POSIXLY_CORRECT]) ;; - esac - ]) - if test "$gl_cv_func_getopt_gnu" != yes; then - gl_replace_getopt=yes - else - AC_CACHE_CHECK([for working GNU getopt_long function], - [gl_cv_func_getopt_long_gnu], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #include - ]], - [[static const struct option long_options[] = - { - { "xtremely-",no_argument, NULL, 1003 }, - { "xtra", no_argument, NULL, 1001 }, - { "xtreme", no_argument, NULL, 1002 }, - { "xtremely", no_argument, NULL, 1003 }, - { NULL, 0, NULL, 0 } - }; - /* This code fails on OpenBSD 5.0. */ - { - static char program[] = "program"; - static char xtremel[] = "--xtremel"; - char *argv[] = { program, xtremel, NULL }; - int option_index; - optind = 1; opterr = 0; - if (getopt_long (2, argv, "", long_options, &option_index) != 1003) - return 1; - } - return 0; - ]])], - [gl_cv_func_getopt_long_gnu=yes], - [gl_cv_func_getopt_long_gnu=no], - [dnl Cross compiling. Guess no on OpenBSD, yes otherwise. - case "$host_os" in - openbsd*) gl_cv_func_getopt_long_gnu="guessing no";; - *) gl_cv_func_getopt_long_gnu="guessing yes";; - esac - ]) - ]) - case "$gl_cv_func_getopt_long_gnu" in - *yes) ;; - *) gl_replace_getopt=yes ;; - esac - fi - fi -]) -m4trace:gnulib-m4/getopt.m4:366: -1- AC_DEFUN([gl_GETOPT_SUBSTITUTE_HEADER], [ - AC_CHECK_HEADERS_ONCE([sys/cdefs.h]) - if test $ac_cv_header_sys_cdefs_h = yes; then - HAVE_SYS_CDEFS_H=1 - else - HAVE_SYS_CDEFS_H=0 - fi - AC_SUBST([HAVE_SYS_CDEFS_H]) - - AC_DEFINE([__GETOPT_PREFIX], [[rpl_]], - [Define to rpl_ if the getopt replacement functions and variables - should be used.]) - GL_GENERATE_GETOPT_H=true - GL_GENERATE_GETOPT_CDEFS_H=true -]) -m4trace:gnulib-m4/getprogname.m4:10: -1- AC_DEFUN([gl_FUNC_GETPROGNAME], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - gl_CHECK_FUNCS_ANDROID([getprogname], [[#include ]]) - if test $ac_cv_func_getprogname = no; then - HAVE_GETPROGNAME=0 - case "$gl_cv_onwards_func_getprogname" in - future*) REPLACE_GETPROGNAME=1 ;; - esac - fi - AC_CHECK_DECLS([program_invocation_name], - [], - [HAVE_DECL_PROGRAM_INVOCATION_NAME=0], - [[#include ]]) -]) -m4trace:gnulib-m4/getprogname.m4:27: -1- AC_DEFUN([gl_PREREQ_GETPROGNAME], [ - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_CHECK_FUNCS_ONCE([getexecname]) - ac_found=0 - AC_CHECK_DECLS([program_invocation_name], [ac_found=1], [], - [#include ]) - AC_CHECK_DECLS([program_invocation_short_name], [ac_found=1], [], - [#include ]) - AC_CHECK_DECLS([__argv], [ac_found=1], [], [#include ]) - - # Incur the cost of this test only if none of the above worked. - if test $ac_found = 0; then - # On OpenBSD 5.1, using the global __progname variable appears to be - # the only way to implement getprogname. - AC_CACHE_CHECK([whether __progname is defined in default libraries], - [gl_cv_var___progname], - [ - gl_cv_var___progname= - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[extern char *__progname;]], - [[return *__progname;]] - )], - [gl_cv_var___progname=yes] - ) - ] - ) - if test "$gl_cv_var___progname" = yes; then - AC_DEFINE([HAVE_VAR___PROGNAME], 1, - [Define if you have a global __progname variable]) - fi - fi -]) -m4trace:gnulib-m4/gnulib-common.m4:11: -1- AC_DEFUN([gl_COMMON], [ - dnl Use AC_REQUIRE here, so that the code is expanded once only. - AC_REQUIRE([gl_00GNULIB]) - AC_REQUIRE([gl_COMMON_BODY]) - AC_REQUIRE([gl_ZZGNULIB]) -]) -m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ - AH_VERBATIM([0witness], -[/* Witness that has been included. */ +m4trace:configure.ac:73: -1- AC_DEFINE_TRACE_LITERAL([__USE_MINGW_ANSI_STDIO]) +m4trace:configure.ac:73: -1- m4_pattern_allow([^__USE_MINGW_ANSI_STDIO$]) +m4trace:configure.ac:74: -1- AM_PROG_CC_C_O +m4trace:configure.ac:78: -1- AC_SUBST([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([FOREIGN_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([FOREIGN_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^FOREIGN_WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([NO_EXPENSIVE_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([NO_EXPENSIVE_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^NO_EXPENSIVE_WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([FOREIGN_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([FOREIGN_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^FOREIGN_WARN_CFLAGS$]) +m4trace:configure.ac:78: -1- AC_SUBST([NO_EXPENSIVE_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- AC_SUBST_TRACE([NO_EXPENSIVE_WARN_CFLAGS]) +m4trace:configure.ac:78: -1- m4_pattern_allow([^NO_EXPENSIVE_WARN_CFLAGS$]) +m4trace:configure.ac:82: -1- LT_INIT([win32-dll]) +m4trace:configure.ac:82: -1- m4_pattern_forbid([^_?LT_[A-Z_]+$]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$]) +m4trace:configure.ac:82: -1- AC_REQUIRE_AUX_FILE([ltmain.sh]) +m4trace:configure.ac:82: -1- AC_SUBST([AS]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([AS]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^AS$]) +m4trace:configure.ac:82: -1- AC_SUBST([DLLTOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DLLTOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DLLTOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([OBJDUMP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([OBJDUMP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^OBJDUMP$]) +m4trace:configure.ac:82: -1- AC_SUBST([LIBTOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LIBTOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LIBTOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([SED]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([SED]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^SED$]) +m4trace:configure.ac:82: -1- AC_SUBST([GREP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([GREP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^GREP$]) +m4trace:configure.ac:82: -1- AC_SUBST([EGREP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([EGREP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^EGREP$]) +m4trace:configure.ac:82: -1- AC_SUBST([FGREP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([FGREP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^FGREP$]) +m4trace:configure.ac:82: -1- AC_SUBST([GREP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([GREP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^GREP$]) +m4trace:configure.ac:82: -1- AC_SUBST([LD]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LD]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LD$]) +m4trace:configure.ac:82: -1- AC_SUBST([DUMPBIN]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DUMPBIN]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DUMPBIN$]) +m4trace:configure.ac:82: -1- AC_SUBST([ac_ct_DUMPBIN]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([ac_ct_DUMPBIN]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^ac_ct_DUMPBIN$]) +m4trace:configure.ac:82: -1- AC_SUBST([DUMPBIN]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DUMPBIN]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DUMPBIN$]) +m4trace:configure.ac:82: -1- AC_SUBST([NM]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([NM]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^NM$]) +m4trace:configure.ac:82: -1- AC_SUBST([LN_S], [$as_ln_s]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LN_S]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LN_S$]) +m4trace:configure.ac:82: -1- AC_SUBST([FILECMD]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([FILECMD]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^FILECMD$]) +m4trace:configure.ac:82: -1- AC_SUBST([OBJDUMP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([OBJDUMP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^OBJDUMP$]) +m4trace:configure.ac:82: -1- AC_SUBST([OBJDUMP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([OBJDUMP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^OBJDUMP$]) +m4trace:configure.ac:82: -1- AC_SUBST([DLLTOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DLLTOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DLLTOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([DLLTOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DLLTOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DLLTOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([AR]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([AR]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^AR$]) +m4trace:configure.ac:82: -1- AC_SUBST([ac_ct_AR]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([ac_ct_AR]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^ac_ct_AR$]) +m4trace:configure.ac:82: -1- AC_SUBST([STRIP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([STRIP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^STRIP$]) +m4trace:configure.ac:82: -1- m4_pattern_allow([LT_OBJDIR]) +m4trace:configure.ac:82: -1- AC_DEFINE_TRACE_LITERAL([LT_OBJDIR]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LT_OBJDIR$]) +m4trace:configure.ac:82: -1- AH_OUTPUT([LT_OBJDIR], [/* Define to the sub-directory where libtool stores uninstalled libraries. */ +@%:@undef LT_OBJDIR]) +m4trace:configure.ac:82: -1- LT_SUPPORTED_TAG([CC]) +m4trace:configure.ac:82: -1- AC_SUBST([MANIFEST_TOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([MANIFEST_TOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^MANIFEST_TOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([DSYMUTIL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([DSYMUTIL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^DSYMUTIL$]) +m4trace:configure.ac:82: -1- AC_SUBST([NMEDIT]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([NMEDIT]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^NMEDIT$]) +m4trace:configure.ac:82: -1- AC_SUBST([LIPO]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LIPO]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LIPO$]) +m4trace:configure.ac:82: -1- AC_SUBST([OTOOL]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([OTOOL]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^OTOOL$]) +m4trace:configure.ac:82: -1- AC_SUBST([OTOOL64]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([OTOOL64]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^OTOOL64$]) +m4trace:configure.ac:82: -1- AC_SUBST([LT_SYS_LIBRARY_PATH]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LT_SYS_LIBRARY_PATH]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LT_SYS_LIBRARY_PATH$]) +m4trace:configure.ac:82: -1- AH_OUTPUT([HAVE_DLFCN_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_DLFCN_H]) +m4trace:configure.ac:82: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DLFCN_H]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^HAVE_DLFCN_H$]) +m4trace:configure.ac:82: -1- LT_SUPPORTED_TAG([CXX]) +m4trace:configure.ac:82: -1- AC_SUBST([CXXCPP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([CXXCPP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^CXXCPP$]) +m4trace:configure.ac:82: -1- AC_SUBST([CPPFLAGS]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([CPPFLAGS]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^CPPFLAGS$]) +m4trace:configure.ac:82: -1- AC_SUBST([CXXCPP]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([CXXCPP]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^CXXCPP$]) +m4trace:configure.ac:82: -1- AC_SUBST([LD]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LD]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LD$]) +m4trace:configure.ac:82: -1- AC_SUBST([LT_SYS_LIBRARY_PATH]) +m4trace:configure.ac:82: -1- AC_SUBST_TRACE([LT_SYS_LIBRARY_PATH]) +m4trace:configure.ac:82: -1- m4_pattern_allow([^LT_SYS_LIBRARY_PATH$]) +m4trace:configure.ac:86: -1- LT_SUPPORTED_TAG([RC]) +m4trace:configure.ac:86: -1- AC_SUBST([RC]) +m4trace:configure.ac:86: -1- AC_SUBST_TRACE([RC]) +m4trace:configure.ac:86: -1- m4_pattern_allow([^RC$]) +m4trace:configure.ac:94: -1- AM_CONDITIONAL([WOE32], [test $is_woe32 = yes]) +m4trace:configure.ac:94: -1- AC_SUBST([WOE32_TRUE]) +m4trace:configure.ac:94: -1- AC_SUBST_TRACE([WOE32_TRUE]) +m4trace:configure.ac:94: -1- m4_pattern_allow([^WOE32_TRUE$]) +m4trace:configure.ac:94: -1- AC_SUBST([WOE32_FALSE]) +m4trace:configure.ac:94: -1- AC_SUBST_TRACE([WOE32_FALSE]) +m4trace:configure.ac:94: -1- m4_pattern_allow([^WOE32_FALSE$]) +m4trace:configure.ac:94: -1- _AM_SUBST_NOTMAKE([WOE32_TRUE]) +m4trace:configure.ac:94: -1- _AM_SUBST_NOTMAKE([WOE32_FALSE]) +m4trace:configure.ac:97: -1- AC_SUBST([WINDRES]) +m4trace:configure.ac:97: -1- AC_SUBST_TRACE([WINDRES]) +m4trace:configure.ac:97: -1- m4_pattern_allow([^WINDRES$]) +m4trace:configure.ac:105: -1- AM_CONDITIONAL([WINDOWS_NATIVE], [test $is_windows_native = yes]) +m4trace:configure.ac:105: -1- AC_SUBST([WINDOWS_NATIVE_TRUE]) +m4trace:configure.ac:105: -1- AC_SUBST_TRACE([WINDOWS_NATIVE_TRUE]) +m4trace:configure.ac:105: -1- m4_pattern_allow([^WINDOWS_NATIVE_TRUE$]) +m4trace:configure.ac:105: -1- AC_SUBST([WINDOWS_NATIVE_FALSE]) +m4trace:configure.ac:105: -1- AC_SUBST_TRACE([WINDOWS_NATIVE_FALSE]) +m4trace:configure.ac:105: -1- m4_pattern_allow([^WINDOWS_NATIVE_FALSE$]) +m4trace:configure.ac:105: -1- _AM_SUBST_NOTMAKE([WINDOWS_NATIVE_TRUE]) +m4trace:configure.ac:105: -1- _AM_SUBST_NOTMAKE([WINDOWS_NATIVE_FALSE]) +m4trace:configure.ac:111: -1- AM_GNU_GETTEXT([use-libtool], [need-ngettext], [\${top_builddir}/intl]) +m4trace:configure.ac:111: -1- AM_NLS +m4trace:configure.ac:111: -1- AC_SUBST([USE_NLS]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([USE_NLS]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^USE_NLS$]) +m4trace:configure.ac:111: -1- AC_SUBST([GETTEXT_MACRO_VERSION], [0.20]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([GETTEXT_MACRO_VERSION]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^GETTEXT_MACRO_VERSION$]) +m4trace:configure.ac:111: -1- AC_SUBST([MSGFMT]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([MSGFMT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGFMT$]) +m4trace:configure.ac:111: -1- AC_SUBST([GMSGFMT]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([GMSGFMT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^GMSGFMT$]) +m4trace:configure.ac:111: -1- AC_SUBST([GMSGFMT_015]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([GMSGFMT_015]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^GMSGFMT_015$]) +m4trace:configure.ac:111: -1- AC_SUBST([XGETTEXT]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([XGETTEXT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT$]) +m4trace:configure.ac:111: -1- AC_SUBST([XGETTEXT_015]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([XGETTEXT_015]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT_015$]) +m4trace:configure.ac:111: -1- AC_SUBST([MSGMERGE]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([MSGMERGE]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGMERGE$]) +m4trace:configure.ac:111: -1- AC_SUBST([MSGMERGE_FOR_MSGFMT_OPTION]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([MSGMERGE_FOR_MSGFMT_OPTION]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGMERGE_FOR_MSGFMT_OPTION$]) +m4trace:configure.ac:111: -1- AC_SUBST([XGETTEXT_EXTRA_OPTIONS]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([XGETTEXT_EXTRA_OPTIONS]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT_EXTRA_OPTIONS$]) +m4trace:configure.ac:111: -1- AC_REQUIRE_AUX_FILE([config.rpath]) +m4trace:configure.ac:111: -1- AC_DEFINE_TRACE_LITERAL([HAVE_CFPREFERENCESCOPYAPPVALUE]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_CFPREFERENCESCOPYAPPVALUE$]) +m4trace:configure.ac:111: -1- AH_OUTPUT([HAVE_CFPREFERENCESCOPYAPPVALUE], [/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in + the CoreFoundation framework. */ +@%:@undef HAVE_CFPREFERENCESCOPYAPPVALUE]) +m4trace:configure.ac:111: -1- AC_DEFINE_TRACE_LITERAL([HAVE_CFLOCALECOPYPREFERREDLANGUAGES]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_CFLOCALECOPYPREFERREDLANGUAGES$]) +m4trace:configure.ac:111: -1- AH_OUTPUT([HAVE_CFLOCALECOPYPREFERREDLANGUAGES], [/* Define to 1 if you have the Mac OS X function + CFLocaleCopyPreferredLanguages in the CoreFoundation framework. */ +@%:@undef HAVE_CFLOCALECOPYPREFERREDLANGUAGES]) +m4trace:configure.ac:111: -1- AC_SUBST([INTL_MACOSX_LIBS]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([INTL_MACOSX_LIBS]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^INTL_MACOSX_LIBS$]) +m4trace:configure.ac:111: -1- AC_DEFINE_TRACE_LITERAL([ENABLE_NLS]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^ENABLE_NLS$]) +m4trace:configure.ac:111: -1- AH_OUTPUT([ENABLE_NLS], [/* Define to 1 if translation of program messages to the user\'s native + language is requested. */ +@%:@undef ENABLE_NLS]) +m4trace:configure.ac:111: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETTEXT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_GETTEXT$]) +m4trace:configure.ac:111: -1- AH_OUTPUT([HAVE_GETTEXT], [/* Define if the GNU gettext() function is already present or preinstalled. */ +@%:@undef HAVE_GETTEXT]) +m4trace:configure.ac:111: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DCGETTEXT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_DCGETTEXT$]) +m4trace:configure.ac:111: -1- AH_OUTPUT([HAVE_DCGETTEXT], [/* Define if the GNU dcgettext() function is already present or preinstalled. + */ +@%:@undef HAVE_DCGETTEXT]) +m4trace:configure.ac:111: -1- AC_SUBST([USE_INCLUDED_LIBINTL]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([USE_INCLUDED_LIBINTL]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^USE_INCLUDED_LIBINTL$]) +m4trace:configure.ac:111: -1- AC_SUBST([CATOBJEXT]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([CATOBJEXT]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^CATOBJEXT$]) +m4trace:configure.ac:111: -1- AC_SUBST([LIBINTL]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([LIBINTL]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^LIBINTL$]) +m4trace:configure.ac:111: -1- AC_SUBST([LTLIBINTL]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([LTLIBINTL]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^LTLIBINTL$]) +m4trace:configure.ac:111: -1- AC_SUBST([POSUB]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([POSUB]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^POSUB$]) +m4trace:configure.ac:111: -1- AC_SUBST([localedir_c]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([localedir_c]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^localedir_c$]) +m4trace:configure.ac:111: -1- AC_SUBST([localedir_c_make]) +m4trace:configure.ac:111: -1- AC_SUBST_TRACE([localedir_c_make]) +m4trace:configure.ac:111: -1- m4_pattern_allow([^localedir_c_make$]) +m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_LIBTOOL], [false]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_LIBTOOL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_LIBTOOL_TRUE]) +m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_LIBTOOL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_LIBTOOL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_LIBTOOL_FALSE]) +m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_LIBTOOL_FALSE$]) +m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_LIBTOOL_TRUE]) +m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_LIBTOOL_FALSE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([0witness], [/* Witness that has been included. */ #define _GL_CONFIG_H_INCLUDED 1 ]) - AH_VERBATIM([_GL_GNUC_PREREQ], -[/* True if the compiler says it groks GNU C version MAJOR.MINOR. */ +m4trace:configure.ac:114: -1- AH_OUTPUT([_GL_GNUC_PREREQ], [/* True if the compiler says it groks GNU C version MAJOR.MINOR. */ #if defined __GNUC__ && defined __GNUC_MINOR__ -# define _GL_GNUC_PREREQ(major, minor) \ +# define _GL_GNUC_PREREQ(major, minor) \\ ((major) < __GNUC__ + ((minor) <= __GNUC_MINOR__)) #else # define _GL_GNUC_PREREQ(major, minor) 0 #endif ]) - AH_VERBATIM([_Noreturn], -[/* The _Noreturn keyword of C11. */ +m4trace:configure.ac:114: -1- AH_OUTPUT([_Noreturn], [/* The _Noreturn keyword of C11. */ #ifndef _Noreturn -# if (defined __cplusplus \ - && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \ - || (defined _MSC_VER && 1900 <= _MSC_VER)) \ +# if (defined __cplusplus \\ + && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \\ + || (defined _MSC_VER && 1900 <= _MSC_VER)) \\ && 0) /* [[noreturn]] is not practically usable, because with it the syntax extern _Noreturn void func (...); - would not be valid; such a declaration would only be valid with 'extern' - and '_Noreturn' swapped, or without the 'extern' keyword. However, some + would not be valid; such a declaration would only be valid with \'extern\' + and \'_Noreturn\' swapped, or without the \'extern\' keyword. However, some AIX system header files and several gnulib header files use precisely - this syntax with 'extern'. */ + this syntax with \'extern\'. */ # define _Noreturn [[noreturn]] -# elif (defined __clang__ && __clang_major__ < 16 \ +# elif (defined __clang__ && __clang_major__ < 16 \\ && defined _GL_WORK_AROUND_LLVM_BUG_59792) /* Compile with -D_GL_WORK_AROUND_LLVM_BUG_59792 to work around that rare LLVM bug, though you may get many false-alarm warnings. */ # define _Noreturn -# elif ((!defined __cplusplus || defined __clang__) \ - && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \ - || (!defined __STRICT_ANSI__ \ - && (_GL_GNUC_PREREQ (4, 7) \ - || (defined __apple_build_version__ \ - ? 6000000 <= __apple_build_version__ \ +# elif ((!defined __cplusplus || defined __clang__) \\ + && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \\ + || (!defined __STRICT_ANSI__ \\ + && (_GL_GNUC_PREREQ (4, 7) \\ + || (defined __apple_build_version__ \\ + ? 6000000 <= __apple_build_version__ \\ : 3 < __clang_major__ + (5 <= __clang_minor__)))))) /* _Noreturn works as-is. */ # elif _GL_GNUC_PREREQ (2, 8) || defined __clang__ || 0x5110 <= __SUNPRO_C @@ -3037,9 +1163,8 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # endif #endif ]) - AH_VERBATIM([isoc99_inline], -[/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports - the ISO C 99 semantics of 'extern inline' (unlike the GNU C semantics of +m4trace:configure.ac:114: -1- AH_OUTPUT([isoc99_inline], [/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports + the ISO C 99 semantics of \'extern inline\' (unlike the GNU C semantics of earlier versions), but does not display it by setting __GNUC_STDC_INLINE__. __APPLE__ && __MACH__ test for Mac OS X. __APPLE_CC__ tests for the Apple compiler and its version. @@ -3047,17 +1172,16 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ #if defined __APPLE__ && defined __MACH__ && __APPLE_CC__ >= 5465 && !defined __cplusplus && __STDC_VERSION__ >= 199901L && !defined __GNUC_STDC_INLINE__ # define __GNUC_STDC_INLINE__ 1 #endif]) - AH_VERBATIM([attribute], -[/* Attributes. */ +m4trace:configure.ac:114: -1- AH_OUTPUT([attribute], [/* Attributes. */ /* Define _GL_HAS_ATTRIBUTE only once, because on FreeBSD, with gcc < 5, if gets included once again after , __has_attribute(x) expands to 0 always, and redefining _GL_HAS_ATTRIBUTE would turn off all attributes. */ #ifndef _GL_HAS_ATTRIBUTE -# if (defined __has_attribute \ - && (!defined __clang_minor__ \ - || (defined __apple_build_version__ \ - ? 7000000 <= __apple_build_version__ \ +# if (defined __has_attribute \\ + && (!defined __clang_minor__ \\ + || (defined __apple_build_version__ \\ + ? 7000000 <= __apple_build_version__ \\ : 5 <= __clang_major__))) # define _GL_HAS_ATTRIBUTE(attr) __has_attribute (__##attr##__) # else @@ -3095,8 +1219,8 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ /* Use __has_c_attribute if available. However, do not use with pre-C23 GCC, which can issue false positives if -Wpedantic. */ -#if (defined __has_c_attribute \ - && ! (_GL_GNUC_PREREQ (4, 6) \ +#if (defined __has_c_attribute \\ + && ! (_GL_GNUC_PREREQ (4, 6) \\ && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) <= 201710)) # define _GL_HAVE___HAS_C_ATTRIBUTE 1 #else @@ -3117,8 +1241,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # define _GL_BRACKET_BEFORE_ATTRIBUTE 1 # endif #endif -]dnl There is no _GL_ATTRIBUTE_ALIGNED; use stdalign's alignas instead. -[ + /* _GL_ATTRIBUTE_ALLOC_SIZE ((N)) declares that the Nth argument of the function is the size of the returned memory block. _GL_ATTRIBUTE_ALLOC_SIZE ((M, N)) declares that the Mth argument multiplied @@ -3160,7 +1283,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ /* Applies to: functions. */ /* Avoid __attribute__ ((cold)) on MinGW; see thread starting at . - Also, Oracle Studio 12.6 requires 'cold' not '__cold__'. */ + Also, Oracle Studio 12.6 requires \'cold\' not \'__cold__\'. */ #ifndef _GL_ATTRIBUTE_COLD # if _GL_HAS_ATTRIBUTE (cold) && !defined __MINGW32__ # ifndef __SUNPRO_C @@ -3192,7 +1315,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ that can be freed by passing them as the Ith argument to the function F. _GL_ATTRIBUTE_DEALLOC_FREE declares that the function returns pointers that - can be freed via 'free'; it can be used only after declaring 'free'. */ + can be freed via \'free\'; it can be used only after declaring \'free\'. */ /* Applies to: functions. Cannot be used on inline functions. */ #ifndef _GL_ATTRIBUTE_DEALLOC # if _GL_GNUC_PREREQ (11, 0) @@ -3201,16 +1324,16 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # define _GL_ATTRIBUTE_DEALLOC(f, i) # endif #endif -/* If gnulib's or has already defined this macro, continue +/* If gnulib\'s or has already defined this macro, continue to use this earlier definition, since may not have been included yet. */ #ifndef _GL_ATTRIBUTE_DEALLOC_FREE # if defined __cplusplus && defined __GNUC__ && !defined __clang__ /* Work around GCC bug */ -# define _GL_ATTRIBUTE_DEALLOC_FREE \ +# define _GL_ATTRIBUTE_DEALLOC_FREE \\ _GL_ATTRIBUTE_DEALLOC ((void (*) (void *)) free, 1) # else -# define _GL_ATTRIBUTE_DEALLOC_FREE \ +# define _GL_ATTRIBUTE_DEALLOC_FREE \\ _GL_ATTRIBUTE_DEALLOC (free, 1) # endif #endif @@ -3258,7 +1381,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ #endif /* _GL_ATTRIBUTE_EXTERNALLY_VISIBLE declares that the entity should remain - visible to debuggers etc., even with '-fwhole-program'. */ + visible to debuggers etc., even with \'-fwhole-program\'. */ /* Applies to: functions, variables. */ #ifndef _GL_ATTRIBUTE_EXTERNALLY_VISIBLE # if _GL_HAS_ATTRIBUTE (externally_visible) @@ -3269,9 +1392,9 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ #endif /* _GL_ATTRIBUTE_FALLTHROUGH declares that it is not a programming mistake if - the control flow falls through to the immediately following 'case' or - 'default' label. The compiler should not warn in this case. */ -/* Applies to: Empty statement (;), inside a 'switch' statement. */ + the control flow falls through to the immediately following \'case\' or + \'default\' label. The compiler should not warn in this case. */ +/* Applies to: Empty statement (;), inside a \'switch\' statement. */ /* Always expands to something. */ #ifndef _GL_ATTRIBUTE_FALLTHROUGH # if _GL_HAVE___HAS_C_ATTRIBUTE @@ -3294,7 +1417,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ scanf, gnu_scanf, strftime, gnu_strftime, strfmon, - or the same thing prefixed and suffixed with '__'. + or the same thing prefixed and suffixed with \'__\'. If FIRST-TO-CHECK is not 0, arguments starting at FIRST-TO_CHECK are suitable for the format string. */ /* Applies to: functions. */ @@ -3353,7 +1476,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ - typedef, in C++ also: class. */ /* In C++ and C23, this is spelled [[__maybe_unused__]]. - GCC's syntax is __attribute__ ((__unused__)). + GCC\'s syntax is __attribute__ ((__unused__)). clang supports both syntaxes. Except that with clang ≥ 6, < 10, in C++ mode, __has_c_attribute (__maybe_unused__) yields true but the use of [[__maybe_unused__]] nevertheless produces a warning. */ @@ -3435,7 +1558,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ /* _GL_ATTRIBUTE_NONSTRING declares that the contents of a character array is not meant to be NUL-terminated. */ /* Applies to: struct/union members and variables that are arrays of element - type '[[un]signed] char'. */ + type \'[[un]signed] char\'. */ #ifndef _GL_ATTRIBUTE_NONSTRING # if _GL_HAS_ATTRIBUTE (nonstring) # define _GL_ATTRIBUTE_NONSTRING __attribute__ ((__nonstring__)) @@ -3449,7 +1572,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ /* _GL_ATTRIBUTE_NOTHROW declares that the function does not throw exceptions. */ /* Applies to: functions. */ -/* After a function's parameter list, this attribute must come first, before +/* After a function\'s parameter list, this attribute must come first, before other attributes. */ #ifndef _GL_ATTRIBUTE_NOTHROW # if defined __cplusplus @@ -3500,7 +1623,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # endif #endif -/* _GL_ATTRIBUTE_RETURNS_NONNULL declares that the function's return value is +/* _GL_ATTRIBUTE_RETURNS_NONNULL declares that the function\'s return value is a non-NULL pointer. */ /* Applies to: functions. */ #ifndef _GL_ATTRIBUTE_RETURNS_NONNULL @@ -3524,7 +1647,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # endif #endif -/* A helper macro. Don't use it directly. */ +/* A helper macro. Don\'t use it directly. */ #ifndef _GL_ATTRIBUTE_UNUSED # if _GL_HAS_ATTRIBUTE (unused) # define _GL_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) @@ -3533,13 +1656,12 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # endif #endif -]dnl There is no _GL_ATTRIBUTE_VISIBILITY; see m4/visibility.m4 instead. -[ + /* _GL_UNUSED_LABEL; declares that it is not a programming mistake if the immediately preceding label is not used. The compiler should not warn if the label is not used. */ /* Applies to: label (both in C and C++). */ -/* Note that g++ < 4.5 does not support the '__attribute__ ((__unused__)) ;' +/* Note that g++ < 4.5 does not support the \'__attribute__ ((__unused__)) ;\' syntax. But clang does. */ #ifndef _GL_UNUSED_LABEL # if !(defined __cplusplus && !_GL_GNUC_PREREQ (4, 5)) || defined __clang__ @@ -3549,8 +1671,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # endif #endif ]) - AH_VERBATIM([c_linkage], -[/* In C++, there is the concept of "language linkage", that encompasses +m4trace:configure.ac:114: -1- AH_OUTPUT([c_linkage], [/* In C++, there is the concept of "language linkage", that encompasses name mangling and function calling conventions. The following macros start and end a block of "C" linkage. */ #ifdef __cplusplus @@ -3561,8 +1682,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ # define _GL_END_C_LINKAGE #endif ]) - AH_VERBATIM([async_safe], -[/* The _GL_ASYNC_SAFE marker should be attached to functions that are +m4trace:configure.ac:114: -1- AH_OUTPUT([async_safe], [/* The _GL_ASYNC_SAFE marker should be attached to functions that are signal handlers (for signals other than SIGABRT, SIGPIPE) or can be invoked from such signal handlers. Such functions have some restrictions: * All functions that it calls should be marked _GL_ASYNC_SAFE as well, @@ -3571,7 +1691,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ section 2.4.3. Note that malloc(), sprintf(), and fwrite(), in particular, are NOT async-signal-safe. * All memory locations (variables and struct fields) that these functions - access must be marked 'volatile'. This holds for both read and write + access must be marked \'volatile\'. This holds for both read and write accesses. Otherwise the compiler might optimize away stores to and reads from such locations that occur in the program, depending on its data flow analysis. For example, when the program contains a loop @@ -3579,7 +1699,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ while (!signal_occurred) ; the compiler is allowed to transform this into an endless loop if the - variable 'signal_occurred' is not declared 'volatile'. + variable \'signal_occurred\' is not declared \'volatile\'. Additionally, recall that: * A signal handler should not modify errno (except if it is a handler for a fatal signal and ends by raising the same signal again, thus @@ -3588,8 +1708,7 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ errno. */ #define _GL_ASYNC_SAFE ]) - AH_VERBATIM([micro_optimizations], -[/* _GL_CMP (n1, n2) performs a three-valued comparison on n1 vs. n2, where +m4trace:configure.ac:114: -1- AH_OUTPUT([micro_optimizations], [/* _GL_CMP (n1, n2) performs a three-valued comparison on n1 vs. n2, where n1 and n2 are expressions without side effects, that evaluate to real numbers (excluding NaN). It returns @@ -3600,9291 +1719,16 @@ m4trace:gnulib-m4/gnulib-common.m4:17: -1- AC_DEFUN([gl_COMMON_BODY], [ jump with nearly all GCC versions up to GCC 10. This variant (n1 < n2 ? -1 : n1 > n2) produces a conditional with many GCC versions up to GCC 9. - The better code (n1 > n2) - (n1 < n2) from Hacker's Delight § 2-9 + The better code (n1 > n2) - (n1 < n2) from Hacker\'s Delight § 2-9 avoids conditional jumps in all GCC versions >= 3.4. */ #define _GL_CMP(n1, n2) (((n1) > (n2)) - ((n1) < (n2))) ]) - dnl Hint which direction to take regarding cross-compilation guesses: - dnl When a user installs a program on a platform they are not intimately - dnl familiar with, --enable-cross-guesses=conservative is the appropriate - dnl choice. It implements the "If we don't know, assume the worst" principle. - dnl However, when an operating system developer (on a platform which is not - dnl yet known to gnulib) builds packages for their platform, they want to - dnl expose, not hide, possible platform bugs; in this case, - dnl --enable-cross-guesses=risky is the appropriate choice. - dnl Sets the variables - dnl gl_cross_guess_normal (to be used when 'yes' is good and 'no' is bad), - dnl gl_cross_guess_inverted (to be used when 'no' is good and 'yes' is bad). - AC_ARG_ENABLE([cross-guesses], - [AS_HELP_STRING([[--enable-cross-guesses={conservative|risky}]], - [specify policy for cross-compilation guesses])], - [if test "x$enableval" != xconservative && test "x$enableval" != xrisky; then - AC_MSG_WARN([invalid argument supplied to --enable-cross-guesses]) - enableval=conservative - fi - gl_cross_guesses="$enableval"], - [gl_cross_guesses=conservative]) - if test $gl_cross_guesses = risky; then - gl_cross_guess_normal="guessing yes" - gl_cross_guess_inverted="guessing no" - else - gl_cross_guess_normal="guessing no" - gl_cross_guess_inverted="guessing yes" - fi - dnl Preparation for running test programs: - dnl Tell glibc to write diagnostics from -D_FORTIFY_SOURCE=2 to stderr, not - dnl to /dev/tty, so they can be redirected to log files. Such diagnostics - dnl arise e.g., in the macros gl_PRINTF_DIRECTIVE_N, gl_SNPRINTF_DIRECTIVE_N. - LIBC_FATAL_STDERR_=1 - export LIBC_FATAL_STDERR_ -]) -m4trace:gnulib-m4/gnulib-common.m4:673: -1- AC_DEFUN([gl_MODULE_INDICATOR_INIT_VARIABLE], [ - GL_MODULE_INDICATOR_PREFIX[]_[$1]=m4_if([$2], , [0], [$2]) - AC_SUBST(GL_MODULE_INDICATOR_PREFIX[]_[$1]) -]) -m4trace:gnulib-m4/gnulib-common.m4:688: -1- AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE], [ - gl_MODULE_INDICATOR_SET_VARIABLE_AUX( - [GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[$1]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], - [gl_MODULE_INDICATOR_CONDITION]) -]) -m4trace:gnulib-m4/gnulib-common.m4:701: -1- AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE_AUX], [ - m4_if(m4_defn([gl_MODULE_INDICATOR_CONDITION]), [1], - [ - dnl Simplify the expression VALUE || 1 to 1. - $1=1 - ], - [gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR([$1], - [gl_MODULE_INDICATOR_CONDITION])]) -]) -m4trace:gnulib-m4/gnulib-common.m4:715: -1- AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR], [ - dnl Simplify the expression 1 || CONDITION to 1. - if test "$[]$1" != 1; then - dnl Simplify the expression 0 || CONDITION to CONDITION. - if test "$[]$1" = 0; then - $1=$2 - else - $1="($[]$1 || $2)" - fi - fi -]) -m4trace:gnulib-m4/gnulib-common.m4:740: -1- AC_DEFUN([gl_MODULE_INDICATOR], [ - AC_DEFINE_UNQUOTED([GNULIB_]m4_translit([[$1]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___]), - [gl_MODULE_INDICATOR_CONDITION], - [Define to a C preprocessor expression that evaluates to 1 or 0, - depending whether the gnulib module $1 shall be considered present.]) -]) -m4trace:gnulib-m4/gnulib-common.m4:763: -1- AC_DEFUN([gl_MODULE_INDICATOR_FOR_TESTS], [ - AC_DEFINE([GNULIB_TEST_]m4_translit([[$1]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___]), [1], - [Define to 1 when the gnulib module $1 should be tested.]) -]) -m4trace:gnulib-m4/gnulib-common.m4:775: -1- AC_DEFUN([gl_ASSERT_NO_GNULIB_POSIXCHECK], [ - dnl Override gl_WARN_ON_USE_PREPARE. - dnl But hide this definition from 'aclocal'. - AC_DEFUN([gl_W][ARN_ON_USE_PREPARE], []) -]) -m4trace:gnulib-m4/gnulib-common.m4:786: -1- AC_DEFUN([gl_ASSERT_NO_GNULIB_TESTS], [ - dnl Override gl_MODULE_INDICATOR_FOR_TESTS. - AC_DEFUN([gl_MODULE_INDICATOR_FOR_TESTS], []) -]) -m4trace:gnulib-m4/gnulib-common.m4:794: -1- AC_DEFUN([gl_FEATURES_H], [ - AC_CHECK_HEADERS_ONCE([features.h]) - if test $ac_cv_header_features_h = yes; then - HAVE_FEATURES_H=1 - else - HAVE_FEATURES_H=0 - fi - AC_SUBST([HAVE_FEATURES_H]) -]) -m4trace:gnulib-m4/gnulib-common.m4:808: -1- AC_DEFUN([gl_PROG_CC_C99], [ - dnl Just use AC_PROG_CC_C99. - dnl When AC_PROG_CC_C99 and AC_PROG_CC_STDC are used together, the substituted - dnl value of CC will contain the C99 enabling options twice. But this is only - dnl a cosmetic problem. - dnl With Autoconf >= 2.70, use AC_PROG_CC since it implies AC_PROG_CC_C99; - dnl this avoids a "warning: The macro `AC_PROG_CC_C99' is obsolete." - m4_version_prereq([2.70], - [AC_REQUIRE([AC_PROG_CC])], - [AC_REQUIRE([AC_PROG_CC_C99])]) -]) -m4trace:gnulib-m4/gnulib-common.m4:825: -1- AC_DEFUN([gl_PROG_AR_RANLIB], [ - dnl Minix 3 comes with two toolchains: The Amsterdam Compiler Kit compiler - dnl as "cc", and GCC as "gcc". They have different object file formats and - dnl library formats. In particular, the GNU binutils programs ar and ranlib - dnl produce libraries that work only with gcc, not with cc. - AC_REQUIRE([AC_PROG_CC]) - dnl The '' hides this use from 'aclocal'. - AC_BEFORE([$0], [A][M_PROG_AR]) - AC_CACHE_CHECK([for Minix Amsterdam compiler], [gl_cv_c_amsterdam_compiler], - [ - AC_EGREP_CPP([Amsterdam], - [ -#ifdef __ACK__ -Amsterdam -#endif - ], - [gl_cv_c_amsterdam_compiler=yes], - [gl_cv_c_amsterdam_compiler=no]) - ]) - - dnl Don't compete with AM_PROG_AR's decision about AR/ARFLAGS if we are not - dnl building with __ACK__. - if test $gl_cv_c_amsterdam_compiler = yes; then - if test -z "$AR"; then - AR='cc -c.a' - fi - if test -z "$ARFLAGS"; then - ARFLAGS='-o' - fi - else - dnl AM_PROG_AR was added in automake v1.11.2. AM_PROG_AR does not AC_SUBST - dnl ARFLAGS variable (it is filed into Makefile.in directly by automake - dnl script on-demand, if not specified by ./configure of course). - dnl Don't AC_REQUIRE the AM_PROG_AR otherwise the code for __ACK__ above - dnl will be ignored. Also, pay attention to call AM_PROG_AR in else block - dnl because AM_PROG_AR is written so it could re-set AR variable even for - dnl __ACK__. It may seem like its easier to avoid calling the macro here, - dnl but we need to AC_SUBST both AR/ARFLAGS (thus those must have some good - dnl default value and automake should usually know them). - dnl - dnl The '' hides this use from 'aclocal'. - m4_ifdef([A][M_PROG_AR], [A][M_PROG_AR], [:]) - fi - - dnl In case the code above has not helped with setting AR/ARFLAGS, use - dnl Automake-documented default values for AR and ARFLAGS, but prefer - dnl ${host}-ar over ar (useful for cross-compiling). - AC_CHECK_TOOL([AR], [ar], [ar]) - if test -z "$ARFLAGS"; then - ARFLAGS='cr' - fi - - AC_SUBST([AR]) - AC_SUBST([ARFLAGS]) - if test -z "$RANLIB"; then - if test $gl_cv_c_amsterdam_compiler = yes; then - RANLIB=':' - else - dnl Use the ranlib program if it is available. - AC_PROG_RANLIB - fi - fi - AC_SUBST([RANLIB]) -]) -m4trace:gnulib-m4/gnulib-common.m4:945: -1- AC_DEFUN([gl_BIGENDIAN], [ - AC_C_BIGENDIAN -]) -m4trace:gnulib-m4/gnulib-common.m4:959: -1- AC_DEFUN([gl_SILENT], [ - exec GL_TMP_FD>&AS_MESSAGE_FD AS_MESSAGE_FD>/dev/null - $1 - exec AS_MESSAGE_FD>&GL_TMP_FD GL_TMP_FD>&- -]) -m4trace:gnulib-m4/gnulib-common.m4:971: -1- AC_DEFUN([gl_CACHE_VAL_SILENT], [ - gl_SILENT([ - AC_CACHE_VAL([$1], [$2]) - ]) -]) -m4trace:gnulib-m4/gnulib-common.m4:985: -1- AC_DEFUN([gl_CONDITIONAL], [ - pushdef([AC_CONFIG_COMMANDS_PRE], [:])dnl - AM_CONDITIONAL([$1], [$2]) - popdef([AC_CONFIG_COMMANDS_PRE])dnl - if test -z "${[$1]_TRUE}" && test -z "${[$1]_FALSE}"; then - [$1]_TRUE='#' - [$1]_FALSE='#' - fi -]) -m4trace:gnulib-m4/gnulib-common.m4:1001: -1- AC_DEFUN([gl_CC_ALLOW_WARNINGS], [ - AC_REQUIRE([AC_PROG_CC]) - AC_CACHE_CHECK([for C compiler option to allow warnings], - [gl_cv_cc_wallow], - [rm -f conftest* - echo 'int dummy;' > conftest.c - AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -c conftest.c 2>conftest1.err]) >/dev/null - AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -Wno-error -c conftest.c 2>conftest2.err]) >/dev/null - dnl Test the number of error output lines, because AIX xlc accepts the - dnl option '-Wno-error', just to produce a warning - dnl "Option -Wno-error was incorrectly specified. The option will be ignored." - dnl afterwards. - if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then - gl_cv_cc_wallow='-Wno-error' - else - gl_cv_cc_wallow=none - fi - rm -f conftest* - ]) - case "$gl_cv_cc_wallow" in - none) GL_CFLAG_ALLOW_WARNINGS='' ;; - *) GL_CFLAG_ALLOW_WARNINGS="$gl_cv_cc_wallow" ;; - esac - AC_SUBST([GL_CFLAG_ALLOW_WARNINGS]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1031: -1- AC_DEFUN([gl_CXX_ALLOW_WARNINGS], [ - dnl Requires AC_PROG_CXX or gl_PROG_ANSI_CXX. - if test -n "$CXX" && test "$CXX" != no; then - AC_CACHE_CHECK([for C++ compiler option to allow warnings], - [gl_cv_cxx_wallow], - [rm -f conftest* - echo 'int dummy;' > conftest.cc - AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -c conftest.cc 2>conftest1.err]) >/dev/null - AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -Wno-error -c conftest.cc 2>conftest2.err]) >/dev/null - dnl Test the number of error output lines, because AIX xlC accepts the - dnl option '-Wno-error', just to produce a warning - dnl "Option -Wno-error was incorrectly specified. The option will be ignored." - dnl afterwards. - if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then - gl_cv_cxx_wallow='-Wno-error' - else - gl_cv_cxx_wallow=none - fi - rm -f conftest* - ]) - case "$gl_cv_cxx_wallow" in - none) GL_CXXFLAG_ALLOW_WARNINGS='' ;; - *) GL_CXXFLAG_ALLOW_WARNINGS="$gl_cv_cxx_wallow" ;; - esac - else - GL_CXXFLAG_ALLOW_WARNINGS='' - fi - AC_SUBST([GL_CXXFLAG_ALLOW_WARNINGS]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1065: -1- AC_DEFUN([gl_CC_GNULIB_WARNINGS], [ - AC_REQUIRE([gl_CC_ALLOW_WARNINGS]) - dnl Assume that the compiler supports -Wno-* options only if it also supports - dnl -Wno-error. - GL_CFLAG_GNULIB_WARNINGS='' - if test -n "$GL_CFLAG_ALLOW_WARNINGS"; then - dnl Enable these warning options: - dnl - dnl GCC clang - dnl -Wno-cast-qual >= 3 >= 3.9 - dnl -Wno-conversion >= 3 >= 3.9 - dnl -Wno-float-conversion >= 4.9 >= 3.9 - dnl -Wno-float-equal >= 3 >= 3.9 - dnl -Wimplicit-fallthrough >= 7 >= 3.9 - dnl -Wno-pedantic >= 4.8 >= 3.9 - dnl -Wno-sign-compare >= 3 >= 3.9 - dnl -Wno-sign-conversion >= 4.3 >= 3.9 - dnl -Wno-tautological-out-of-range-compare - >= 3.9 - dnl -Wno-type-limits >= 4.3 >= 3.9 - dnl -Wno-undef >= 3 >= 3.9 - dnl -Wno-unsuffixed-float-constants >= 4.5 - dnl -Wno-unused-function >= 3 >= 3.9 - dnl -Wno-unused-parameter >= 3 >= 3.9 - dnl - cat > conftest.c <<\EOF - #if __GNUC__ >= 3 || (__clang_major__ + (__clang_minor__ >= 9) > 3) - -Wno-cast-qual - -Wno-conversion - -Wno-float-equal - -Wno-sign-compare - -Wno-undef - -Wno-unused-function - -Wno-unused-parameter - #endif - #if __GNUC__ + (__GNUC_MINOR__ >= 9) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3) - -Wno-float-conversion - #endif - #if __GNUC__ >= 7 || (__clang_major__ + (__clang_minor__ >= 9) > 3) - -Wimplicit-fallthrough - #endif - #if __GNUC__ + (__GNUC_MINOR__ >= 8) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3) - -Wno-pedantic - #endif - #if 3 < __clang_major__ + (9 <= __clang_minor__) - -Wno-tautological-constant-out-of-range-compare - #endif - #if __GNUC__ + (__GNUC_MINOR__ >= 3) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3) - -Wno-sign-conversion - -Wno-type-limits - #endif - #if __GNUC__ + (__GNUC_MINOR__ >= 5) > 4 - -Wno-unsuffixed-float-constants - #endif -EOF - gl_command="$CC $CFLAGS $CPPFLAGS -E conftest.c > conftest.out" - if AC_TRY_EVAL([gl_command]); then - gl_options=`grep -v '#' conftest.out` - for word in $gl_options; do - GL_CFLAG_GNULIB_WARNINGS="$GL_CFLAG_GNULIB_WARNINGS $word" - done - fi - rm -f conftest.c conftest.out - fi - AC_SUBST([GL_CFLAG_GNULIB_WARNINGS]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1139: -1- AC_DEFUN([gl_CONDITIONAL_HEADER], [ - m4_pushdef([gl_header_name], AS_TR_SH(m4_toupper($1))) - m4_pushdef([gl_generate_var], [GL_GENERATE_]AS_TR_SH(m4_toupper($1))) - m4_pushdef([gl_generate_cond], [GL_GENERATE_]AS_TR_SH(m4_toupper($1))) - case "$gl_generate_var" in - false) gl_header_name='' ;; - true) - dnl It is OK to use a .h file in lib/ from within tests/, but not vice - dnl versa. - if test -z "$gl_header_name"; then - gl_header_name="${gl_source_base_prefix}$1" - fi - ;; - *) echo "*** gl_generate_var is not set correctly" 1>&2; exit 1 ;; - esac - AC_SUBST(gl_header_name) - gl_CONDITIONAL(gl_generate_cond, [$gl_generate_var]) - m4_popdef([gl_generate_cond]) - m4_popdef([gl_generate_var]) - m4_popdef([gl_header_name]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1163: -1- AC_DEFUN([gl_PREPARE_CHECK_FUNCS_MACOS], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_COMPILER_CLANG]) - AC_CACHE_CHECK([for compiler option needed when checking for future declarations], - [gl_cv_compiler_check_future_option], - [case "$host_os" in - dnl This is only needed on macOS. - darwin*) - if test $gl_cv_compiler_clang = yes; then - dnl Test whether the compiler supports the option - dnl '-Werror=unguarded-availability-new'. - saved_ac_compile="$ac_compile" - ac_compile="$ac_compile -Werror=unguarded-availability-new" - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[]])], - [gl_cv_compiler_check_future_option='-Werror=unguarded-availability-new'], - [gl_cv_compiler_check_future_option=none]) - ac_compile="$saved_ac_compile" - else - gl_cv_compiler_check_future_option=none - fi - ;; - *) gl_cv_compiler_check_future_option=none ;; - esac - ]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1195: -1- AC_DEFUN([gl_CHECK_FUNCS_DEFAULT_CASE], [ - *) - AC_CHECK_FUNC([$1]) - [gl_cv_onwards_func_][$1]=$[ac_cv_func_][$1] - ;; -]) -m4trace:gnulib-m4/gnulib-common.m4:1203: -1- AC_DEFUN([gl_CHECK_FUNCS_CASE_FOR_ANDROID], [ - linux*-android*) - AC_CHECK_DECL([$1], , , [$2]) - if test $[ac_cv_have_decl_][$1] = yes; then - AC_CHECK_FUNC([[$1]]) - if test $[ac_cv_func_][$1] = yes; then - [gl_cv_onwards_func_][$1]=yes - else - dnl The function is declared but does not exist. This should not - dnl happen normally. But anyway, we know that a future version - dnl of Android will have the function. - [gl_cv_onwards_func_][$1]='future OS version' - fi - else - [gl_cv_onwards_func_][$1]='future OS version' - fi - ;; -]) -m4trace:gnulib-m4/gnulib-common.m4:1223: -1- AC_DEFUN([gl_CHECK_FUNCS_CASE_FOR_MACOS], [ - darwin*) - if test "x$gl_cv_compiler_check_future_option" != "xnone"; then - dnl Use a compile test, not a link test. - saved_ac_compile="$ac_compile" - ac_compile="$ac_compile $gl_cv_compiler_check_future_option" - saved_ac_compile_for_check_decl="$ac_compile_for_check_decl" - ac_compile_for_check_decl="$ac_compile_for_check_decl $gl_cv_compiler_check_future_option" - unset [ac_cv_have_decl_][$1] - AC_CHECK_DECL([$1], , , [$2]) - ac_compile="$saved_ac_compile" - ac_compile_for_check_decl="$saved_ac_compile_for_check_decl" - [ac_cv_func_][$1]="$[ac_cv_have_decl_][$1]" - if test $[ac_cv_func_][$1] = yes; then - [gl_cv_onwards_func_][$1]=yes - else - unset [ac_cv_have_decl_][$1] - AC_CHECK_DECL([$1], , , [$2]) - if test $[ac_cv_have_decl_][$1] = yes; then - [gl_cv_onwards_func_][$1]='future OS version' - else - [gl_cv_onwards_func_][$1]=no - fi - fi - else - AC_CHECK_FUNC([$1]) - [gl_cv_onwards_func_][$1]=$[ac_cv_func_][$1] - fi - ;; -]) -m4trace:gnulib-m4/gnulib-common.m4:1255: -1- AC_DEFUN([gl_CHECK_FUNCS_SET_RESULTS], [ - case "$[gl_cv_onwards_func_][$1]" in - future*) [ac_cv_func_][$1]=no ;; - *) [ac_cv_func_][$1]=$[gl_cv_onwards_func_][$1] ;; - esac - if test $[ac_cv_func_][$1] = yes; then - AC_DEFINE([HAVE_]m4_translit([[$1]], - [abcdefghijklmnopqrstuvwxyz], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ]), - [1], [Define to 1 if you have the `$1' function.]) - fi -]) -m4trace:gnulib-m4/gnulib-common.m4:1304: -1- AC_DEFUN([gl_CHECK_FUNCS_ANDROID], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([for [$1]], - [[gl_cv_onwards_func_][$1]], - [gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([$1], [$2]) - gl_CHECK_FUNCS_DEFAULT_CASE([$1]) - esac - ]) - ]) - gl_CHECK_FUNCS_SET_RESULTS([$1]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1357: -1- AC_DEFUN([gl_CHECK_FUNCS_MACOS], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_PREPARE_CHECK_FUNCS_MACOS]) - AC_CACHE_CHECK([for [$1]], - [[gl_cv_onwards_func_][$1]], - [gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_MACOS([$1], [$2]) - gl_CHECK_FUNCS_DEFAULT_CASE([$1]) - esac - ]) - ]) - gl_CHECK_FUNCS_SET_RESULTS([$1]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1377: -1- AC_DEFUN([gl_CHECK_FUNCS_ANDROID_MACOS], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_PREPARE_CHECK_FUNCS_MACOS]) - AC_CACHE_CHECK([for [$1]], - [[gl_cv_onwards_func_][$1]], - [gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([$1], [$2]) - gl_CHECK_FUNCS_CASE_FOR_MACOS([$1], [$2]) - gl_CHECK_FUNCS_DEFAULT_CASE([$1]) - esac - ]) - ]) - gl_CHECK_FUNCS_SET_RESULTS([$1]) -]) -m4trace:gnulib-m4/gnulib-common.m4:1403: -1- AC_DEFUN([GL_MDA_DEFINES], [ -AC_REQUIRE([_GL_MDA_DEFINES]) -[$gl_mda_defines] -]) -m4trace:gnulib-m4/gnulib-common.m4:1407: -1- AC_DEFUN([_GL_MDA_DEFINES], [gl_mda_defines=' -#if defined _WIN32 && !defined __CYGWIN__ -#define access _access -#define chdir _chdir -#define chmod _chmod -#define close _close -#define creat _creat -#define dup _dup -#define dup2 _dup2 -#define ecvt _ecvt -#define execl _execl -#define execle _execle -#define execlp _execlp -#define execv _execv -#define execve _execve -#define execvp _execvp -#define execvpe _execvpe -#define fcloseall _fcloseall -#define fcvt _fcvt -#define fdopen _fdopen -#define fileno _fileno -#define gcvt _gcvt -#define getcwd _getcwd -#define getpid _getpid -#define getw _getw -#define isatty _isatty -#define j0 _j0 -#define j1 _j1 -#define jn _jn -#define lfind _lfind -#define lsearch _lsearch -#define lseek _lseek -#define memccpy _memccpy -#define mkdir _mkdir -#define mktemp _mktemp -#define open _open -#define putenv _putenv -#define putw _putw -#define read _read -#define rmdir _rmdir -#define strdup _strdup -#define swab _swab -#define tempnam _tempnam -#define tzset _tzset -#define umask _umask -#define unlink _unlink -#define utime _utime -#define wcsdup _wcsdup -#define write _write -#define y0 _y0 -#define y1 _y1 -#define yn _yn -#endif -' -]) -m4trace:gnulib-m4/gnulib-comp.m4:34: -1- AC_DEFUN([gl_EARLY], [ - m4_pattern_forbid([^gl_[A-Z]])dnl the gnulib macro namespace - m4_pattern_allow([^gl_ES$])dnl a valid locale name - m4_pattern_allow([^gl_LIBOBJS$])dnl a variable - m4_pattern_allow([^gl_LTLIBOBJS$])dnl a variable - - # Pre-early section. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_REQUIRE([gl_PROG_AR_RANLIB]) - - # Code from module absolute-header: - # Code from module alignasof: - # Code from module alloca-opt: - # Code from module allocator: - # Code from module ansi-c++-opt: - AC_REQUIRE([gl_ANSI_CXX]) - # Code from module areadlink: - # Code from module assert-h: - # Code from module atexit: - # Code from module attribute: - # Code from module basename-lgpl: - # Code from module binary-io: - # Code from module builtin-expect: - # Code from module c-ctype: - # Code from module c-strcase: - # Code from module c32isalnum: - # Code from module c32isalpha: - # Code from module c32isblank: - # Code from module c32iscntrl: - # Code from module c32isdigit: - # Code from module c32isgraph: - # Code from module c32islower: - # Code from module c32isprint: - # Code from module c32ispunct: - # Code from module c32isspace: - # Code from module c32isupper: - # Code from module c32isxdigit: - # Code from module c32tolower: - # Code from module c32width: - # Code from module c99: - # Code from module calloc-gnu: - # Code from module calloc-posix: - # Code from module canonicalize-lgpl: - # Code from module careadlinkat: - # Code from module cloexec: - # Code from module close: - # Code from module closeout: - # Code from module csharpcomp-script: - # Code from module double-slash-root: - # Code from module dup2: - # Code from module eloop-threshold: - # Code from module environ: - # Code from module errno: - # Code from module error: - # Code from module error-h: - # Code from module exitfail: - # Code from module extensions: - # Code from module extern-inline: - # Code from module fcntl: - # Code from module fcntl-h: - # Code from module fd-hook: - # Code from module filename: - # Code from module flexmember: - # Code from module free-posix: - # Code from module fstat: - # Code from module fwriteerror: - # Code from module gen-header: - # Code from module getdtablesize: - # Code from module getopt-gnu: - # Code from module getopt-posix: - # Code from module getprogname: - # Code from module gettext-h: - # Code from module gettext-runtime-misc: - # Code from module glibc-internal/scratch_buffer: - # Code from module gperf: - # Code from module hard-locale: - # Code from module havelib: - # Code from module ialloc: - # Code from module iconv: - # Code from module iconv-h: - # Code from module iconv_open: - # Code from module idx: - # Code from module include_next: - # Code from module inline: - # Code from module intprops: - # Code from module inttypes-incomplete: - # Code from module iswblank: - # Code from module iswdigit: - # Code from module iswpunct: - # Code from module iswxdigit: - # Code from module java: - # Code from module javacomp-script: - # Code from module langinfo: - # Code from module largefile: - AC_REQUIRE([AC_SYS_LARGEFILE]) - # Code from module libc-config: - # Code from module limits-h: - # Code from module localcharset: - # Code from module locale: - # Code from module localename: - # Code from module localename-unsafe: - # Code from module localename-unsafe-limited: - # Code from module lock: - # Code from module malloc-gnu: - # Code from module malloc-posix: - # Code from module malloca: - # Code from module manywarnings: - # Code from module mbchar: - # Code from module mbrtoc32: - # Code from module mbrtowc: - # Code from module mbsinit: - # Code from module mbslen: - # Code from module mbsstr: - # Code from module mbszero: - # Code from module mbuiter: - # Code from module mbuiterf: - # Code from module memchr: - # Code from module memmove: - # Code from module mempcpy: - # Code from module minmax: - # Code from module msvc-inval: - # Code from module msvc-nothrow: - # Code from module multiarch: - # Code from module nocrash: - # Code from module noreturn: - # Code from module open: - # Code from module pathmax: - # Code from module progname: - # Code from module propername: - # Code from module raise: - # Code from module rawmemchr: - # Code from module readlink: - # Code from module realloc-gnu: - # Code from module realloc-posix: - # Code from module reallocarray: - # Code from module relocatable-prog: - # Code from module relocatable-prog-wrapper: - AC_REQUIRE([AC_SYS_LARGEFILE]) - # Code from module setlocale: - # Code from module setlocale-null: - # Code from module setlocale-null-unlocked: - # Code from module signal-h: - # Code from module sigpipe: - # Code from module sigprocmask: - # Code from module snippet/_Noreturn: - # Code from module snippet/arg-nonnull: - # Code from module snippet/c++defs: - # Code from module snippet/warn-on-use: - # Code from module ssize_t: - # Code from module stat: - # Code from module stat-time: - # Code from module std-gnu11: - # Code from module stdbool: - # Code from module stdckdint: - # Code from module stddef: - # Code from module stdint: - # Code from module stdio: - gl_STDIO_H_EARLY - # Code from module stdlib: - # Code from module streq: - # Code from module strerror: - # Code from module strerror-override: - # Code from module striconv: - # Code from module string: - # Code from module strnlen: - # Code from module strnlen1: - # Code from module strtoul: - # Code from module sys_stat: - # Code from module sys_types: - # Code from module thread-optim: - # Code from module threadlib: - gl_THREADLIB_EARLY - # Code from module time-h: - # Code from module trim: - # Code from module uchar: - # Code from module unicase/base: - # Code from module unicase/tolower: - # Code from module unictype/base: - # Code from module unictype/ctype-alnum: - # Code from module unictype/ctype-alpha: - # Code from module unictype/ctype-blank: - # Code from module unictype/ctype-cntrl: - # Code from module unictype/ctype-digit: - # Code from module unictype/ctype-graph: - # Code from module unictype/ctype-lower: - # Code from module unictype/ctype-print: - # Code from module unictype/ctype-punct: - # Code from module unictype/ctype-space: - # Code from module unictype/ctype-upper: - # Code from module unictype/ctype-xdigit: - # Code from module uninorm/base: - # Code from module unistd: - # Code from module unistr/base: - # Code from module unistr/u8-mbtoucr: - # Code from module unistr/u8-uctomb: - # Code from module unitypes: - # Code from module uniwidth/base: - # Code from module uniwidth/width: - # Code from module unlocked-io: - # Code from module unlocked-io-internal: - # Code from module vararrays: - # Code from module warnings: - # Code from module wchar: - # Code from module wctype-h: - # Code from module wcwidth: - # Code from module windows-mutex: - # Code from module windows-once: - # Code from module windows-recmutex: - # Code from module windows-rwlock: - # Code from module xalloc: - # Code from module xalloc-die: - # Code from module xalloc-oversized: - # Code from module xreadlink: - # Code from module xstriconv: -]) -m4trace:gnulib-m4/gnulib-comp.m4:253: -1- AC_DEFUN([gl_INIT], [ - AM_CONDITIONAL([GL_COND_LIBTOOL], [false]) - gl_cond_libtool=false - gl_libdeps= - gl_ltlibdeps= - gl_m4_base='gnulib-m4' - m4_pushdef([AC_LIBOBJ], m4_defn([gl_LIBOBJ])) - m4_pushdef([AC_REPLACE_FUNCS], m4_defn([gl_REPLACE_FUNCS])) - m4_pushdef([AC_LIBSOURCES], m4_defn([gl_LIBSOURCES])) - m4_pushdef([gl_LIBSOURCES_LIST], []) - m4_pushdef([gl_LIBSOURCES_DIR], []) - m4_pushdef([GL_MACRO_PREFIX], [gl]) - m4_pushdef([GL_MODULE_INDICATOR_PREFIX], [GL]) - gl_COMMON - gl_source_base='gnulib-lib' - gl_source_base_prefix= - gl_ALIGNASOF - gl_FUNC_ALLOCA - gl_CONDITIONAL_HEADER([alloca.h]) - AC_PROG_MKDIR_P - gl_ASSERT_H - gl_CONDITIONAL_HEADER([assert.h]) - AC_PROG_MKDIR_P - gl_FUNC_ATEXIT - gl_CONDITIONAL([GL_COND_OBJ_ATEXIT], [test $ac_cv_func_atexit = no]) - AM_COND_IF([GL_COND_OBJ_ATEXIT], [ - gl_PREREQ_ATEXIT - ]) - gl___BUILTIN_EXPECT - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isalnum]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isalpha]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isblank]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32iscntrl]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isdigit]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isgraph]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32islower]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isprint]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32ispunct]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isspace]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isupper]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32isxdigit]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32tolower]) - AC_REQUIRE([gl_UCHAR_H]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how mbrtoc32 is implemented. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - gl_UCHAR_MODULE_INDICATOR([c32width]) - gl_FUNC_CALLOC_GNU - if test $REPLACE_CALLOC_FOR_CALLOC_GNU = 1; then - AC_LIBOBJ([calloc]) - fi - gl_STDLIB_MODULE_INDICATOR([calloc-gnu]) - gl_FUNC_CALLOC_POSIX - if test $REPLACE_CALLOC_FOR_CALLOC_POSIX = 1; then - AC_LIBOBJ([calloc]) - fi - gl_STDLIB_MODULE_INDICATOR([calloc-posix]) - gl_CANONICALIZE_LGPL - gl_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL], - [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]) - gl_MODULE_INDICATOR([canonicalize-lgpl]) - gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name]) - gl_STDLIB_MODULE_INDICATOR([realpath]) - AC_REQUIRE([AC_C_RESTRICT]) - gl_CHECK_FUNCS_ANDROID([readlinkat], [[#include ]]) - gl_MODULE_INDICATOR_FOR_TESTS([cloexec]) - gl_FUNC_CLOSE - gl_CONDITIONAL([GL_COND_OBJ_CLOSE], [test $REPLACE_CLOSE = 1]) - gl_UNISTD_MODULE_INDICATOR([close]) - AC_REQUIRE([gt_CSHARPCOMP]) - AC_CONFIG_FILES([csharpcomp.sh:../build-aux/csharpcomp.sh.in]) - gl_DOUBLE_SLASH_ROOT - gl_FUNC_DUP2 - gl_CONDITIONAL([GL_COND_OBJ_DUP2], [test $REPLACE_DUP2 = 1]) - AM_COND_IF([GL_COND_OBJ_DUP2], [ - gl_PREREQ_DUP2 - ]) - gl_UNISTD_MODULE_INDICATOR([dup2]) - gl_ENVIRON - gl_UNISTD_MODULE_INDICATOR([environ]) - gl_HEADER_ERRNO_H - gl_CONDITIONAL_HEADER([errno.h]) - AC_PROG_MKDIR_P - AC_REQUIRE([gl_ERROR_H]) - gl_ERROR - gl_CONDITIONAL([GL_COND_OBJ_ERROR], [test $COMPILE_ERROR_C = 1]) - AM_COND_IF([GL_COND_OBJ_ERROR], [ - gl_PREREQ_ERROR - ]) - m4_ifdef([AM_XGETTEXT_OPTION], - [AM_][XGETTEXT_OPTION([--flag=error:3:c-format]) - AM_][XGETTEXT_OPTION([--flag=error_at_line:5:c-format])]) - gl_ERROR_H - AC_PROG_MKDIR_P - AC_REQUIRE([gl_EXTERN_INLINE]) - gl_FUNC_FCNTL - gl_CONDITIONAL([GL_COND_OBJ_FCNTL], - [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]) - gl_FCNTL_MODULE_INDICATOR([fcntl]) - gl_FCNTL_H - gl_FCNTL_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - AC_C_FLEXIBLE_ARRAY_MEMBER - gl_FUNC_FREE - gl_CONDITIONAL([GL_COND_OBJ_FREE], [test $REPLACE_FREE = 1]) - AM_COND_IF([GL_COND_OBJ_FREE], [ - gl_PREREQ_FREE - ]) - gl_STDLIB_MODULE_INDICATOR([free-posix]) - gl_FUNC_FSTAT - gl_CONDITIONAL([GL_COND_OBJ_FSTAT], [test $REPLACE_FSTAT = 1]) - AM_COND_IF([GL_COND_OBJ_FSTAT], [ - case "$host_os" in - mingw* | windows*) - AC_LIBOBJ([stat-w32]) - ;; - esac - gl_PREREQ_FSTAT - ]) - gl_SYS_STAT_MODULE_INDICATOR([fstat]) - gl_MODULE_INDICATOR([fwriteerror]) - gl_FUNC_GETDTABLESIZE - gl_CONDITIONAL([GL_COND_OBJ_GETDTABLESIZE], - [test $HAVE_GETDTABLESIZE = 0 || test $REPLACE_GETDTABLESIZE = 1]) - AM_COND_IF([GL_COND_OBJ_GETDTABLESIZE], [ - gl_PREREQ_GETDTABLESIZE - ]) - gl_UNISTD_MODULE_INDICATOR([getdtablesize]) - gl_FUNC_GETOPT_GNU - dnl Because of the way gl_FUNC_GETOPT_GNU is implemented (the gl_getopt_required - dnl mechanism), there is no need to do any AC_LIBOBJ or AC_SUBST here; they are - dnl done in the getopt-posix module. - gl_FUNC_GETOPT_POSIX - gl_CONDITIONAL_HEADER([getopt.h]) - gl_CONDITIONAL_HEADER([getopt-cdefs.h]) - AC_PROG_MKDIR_P - gl_CONDITIONAL([GL_COND_OBJ_GETOPT], [test $REPLACE_GETOPT = 1]) - AM_COND_IF([GL_COND_OBJ_GETOPT], [ - dnl Define the substituted variable GNULIB_UNISTD_H_GETOPT to 1. - gl_UNISTD_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT], [1]) - ]) - gl_UNISTD_MODULE_INDICATOR([getopt-posix]) - gl_FUNC_GETPROGNAME - gl_CONDITIONAL([GL_COND_OBJ_GETPROGNAME], - [test $HAVE_GETPROGNAME = 0 || test $REPLACE_GETPROGNAME = 1]) - AM_COND_IF([GL_COND_OBJ_GETPROGNAME], [ - gl_PREREQ_GETPROGNAME - ]) - gl_STDLIB_MODULE_INDICATOR([getprogname]) - AC_SUBST([LIBINTL]) - AC_SUBST([LTLIBINTL]) - AC_PROG_MKDIR_P - AC_REQUIRE([gl_FUNC_SETLOCALE_NULL]) - HARD_LOCALE_LIB="$SETLOCALE_NULL_LIB" - AC_SUBST([HARD_LOCALE_LIB]) - dnl For backward compatibility. - LIB_HARD_LOCALE="$HARD_LOCALE_LIB" - AC_SUBST([LIB_HARD_LOCALE]) - AC_DEFUN([gl_HAVE_MODULE_HAVELIB]) - AM_ICONV - m4_ifdef([gl_ICONV_MODULE_INDICATOR], - [gl_ICONV_MODULE_INDICATOR([iconv])]) - gl_ICONV_H - gl_ICONV_H_REQUIRE_DEFAULTS - gl_CONDITIONAL_HEADER([iconv.h]) - AC_PROG_MKDIR_P - gl_FUNC_ICONV_OPEN - dnl Because of gl_REPLACE_ICONV_H: - gl_CONDITIONAL_HEADER([iconv.h]) - gl_CONDITIONAL([GL_COND_OBJ_ICONV_OPEN], [test $REPLACE_ICONV_OPEN = 1]) - gl_CONDITIONAL([GL_COND_OBJ_ICONV], [test $REPLACE_ICONV = 1]) - gl_INLINE - gl_INTTYPES_INCOMPLETE - gl_INTTYPES_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_FUNC_ISWBLANK - gl_CONDITIONAL([GL_COND_OBJ_ISWBLANK], - [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && { test $HAVE_ISWBLANK = 0 || test $REPLACE_ISWBLANK = 1; }]) - gl_WCTYPE_MODULE_INDICATOR([iswblank]) - gl_FUNC_ISWDIGIT - gl_CONDITIONAL([GL_COND_OBJ_ISWDIGIT], - [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWDIGIT = 1]) - gl_WCTYPE_MODULE_INDICATOR([iswdigit]) - gl_FUNC_ISWPUNCT - gl_CONDITIONAL([GL_COND_OBJ_ISWPUNCT], - [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWPUNCT = 1]) - gl_WCTYPE_MODULE_INDICATOR([iswpunct]) - gl_FUNC_ISWXDIGIT - gl_CONDITIONAL([GL_COND_OBJ_ISWXDIGIT], - [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWXDIGIT = 1]) - gl_WCTYPE_MODULE_INDICATOR([iswxdigit]) - gt_JAVA_CHOICE - # You need to invoke gt_JAVACOMP yourself, possibly with arguments. - AC_CONFIG_FILES([javacomp.sh:../build-aux/javacomp.sh.in]) - gl_LANGINFO_H - gl_LANGINFO_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - AC_REQUIRE([gl_LARGEFILE]) - gl___INLINE - gl_LIMITS_H - gl_CONDITIONAL_HEADER([limits.h]) - AC_PROG_MKDIR_P - gl_LOCALCHARSET - dnl For backward compatibility. Some packages still use this. - LOCALCHARSET_TESTS_ENVIRONMENT= - AC_SUBST([LOCALCHARSET_TESTS_ENVIRONMENT]) - gl_LOCALE_H - gl_LOCALE_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_LOCALENAME_UNSAFE - gl_LOCALE_MODULE_INDICATOR([localename-unsafe]) - gl_MUSL_LIBC - gl_LOCALENAME_UNSAFE_LIMITED - AC_REQUIRE([AC_CANONICAL_HOST]) - gl_CONDITIONAL([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED], - [case "$host_os" in netbsd* | solaris*) true;; *) false;; esac]) - gl_LOCK - gl_MODULE_INDICATOR([lock]) - gl_FUNC_MALLOC_GNU - if test $REPLACE_MALLOC_FOR_MALLOC_GNU = 1; then - AC_LIBOBJ([malloc]) - fi - gl_STDLIB_MODULE_INDICATOR([malloc-gnu]) - AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) - if test $REPLACE_MALLOC_FOR_MALLOC_POSIX = 1; then - AC_LIBOBJ([malloc]) - fi - gl_STDLIB_MODULE_INDICATOR([malloc-posix]) - gl_MALLOCA - gl_MBCHAR - gl_FUNC_MBRTOC32 - gl_CONDITIONAL([GL_COND_OBJ_MBRTOC32], - [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]) - AM_COND_IF([GL_COND_OBJ_MBRTOC32], [ - if test $REPLACE_MBSTATE_T = 1; then - AC_LIBOBJ([lc-charset-dispatch]) - AC_LIBOBJ([mbtowc-lock]) - gl_PREREQ_MBTOWC_LOCK - fi - gl_PREREQ_MBRTOC32 - ]) - gl_UCHAR_MODULE_INDICATOR([mbrtoc32]) - gl_FUNC_MBRTOWC - gl_CONDITIONAL([GL_COND_OBJ_MBRTOWC], - [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]) - AM_COND_IF([GL_COND_OBJ_MBRTOWC], [ - if test $REPLACE_MBSTATE_T = 1; then - AC_LIBOBJ([lc-charset-dispatch]) - AC_LIBOBJ([mbtowc-lock]) - gl_PREREQ_MBTOWC_LOCK - fi - gl_PREREQ_MBRTOWC - ]) - gl_WCHAR_MODULE_INDICATOR([mbrtowc]) - gl_FUNC_MBSINIT - gl_CONDITIONAL([GL_COND_OBJ_MBSINIT], - [test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1]) - AM_COND_IF([GL_COND_OBJ_MBSINIT], [ - gl_PREREQ_MBSINIT - ]) - gl_WCHAR_MODULE_INDICATOR([mbsinit]) - gl_FUNC_MBSLEN - gl_STRING_MODULE_INDICATOR([mbslen]) - gl_STRING_MODULE_INDICATOR([mbsstr]) - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - gl_MBSTATE_T_BROKEN - gl_MUSL_LIBC - gl_WCHAR_MODULE_INDICATOR([mbszero]) - gl_MBITER - gl_MBITER - gl_FUNC_MEMCHR - gl_CONDITIONAL([GL_COND_OBJ_MEMCHR], [test $REPLACE_MEMCHR = 1]) - AM_COND_IF([GL_COND_OBJ_MEMCHR], [ - gl_PREREQ_MEMCHR - ]) - gl_STRING_MODULE_INDICATOR([memchr]) - gl_FUNC_MEMMOVE - gl_CONDITIONAL([GL_COND_OBJ_MEMMOVE], [test $ac_cv_func_memmove = no]) - AM_COND_IF([GL_COND_OBJ_MEMMOVE], [ - gl_PREREQ_MEMMOVE - ]) - gl_FUNC_MEMPCPY - gl_CONDITIONAL([GL_COND_OBJ_MEMPCPY], - [test $HAVE_MEMPCPY = 0 || test $REPLACE_MEMPCPY = 1]) - AM_COND_IF([GL_COND_OBJ_MEMPCPY], [ - gl_PREREQ_MEMPCPY - ]) - gl_STRING_MODULE_INDICATOR([mempcpy]) - gl_MINMAX - AC_REQUIRE([gl_MSVC_INVAL]) - gl_CONDITIONAL([GL_COND_OBJ_MSVC_INVAL], - [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) - AC_REQUIRE([gl_MSVC_NOTHROW]) - gl_CONDITIONAL([GL_COND_OBJ_MSVC_NOTHROW], - [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) - gl_MODULE_INDICATOR([msvc-nothrow]) - gl_MULTIARCH - gl_FUNC_OPEN - gl_CONDITIONAL([GL_COND_OBJ_OPEN], [test $REPLACE_OPEN = 1]) - AM_COND_IF([GL_COND_OBJ_OPEN], [ - gl_PREREQ_OPEN - ]) - gl_FCNTL_MODULE_INDICATOR([open]) - gl_PATHMAX - AC_CHECK_DECLS([program_invocation_name], [], [], [#include ]) - AC_CHECK_DECLS([program_invocation_short_name], [], [], [#include ]) - m4_ifdef([AM_XGETTEXT_OPTION], - [AM_][XGETTEXT_OPTION([--keyword='proper_name:1,\"This is a proper name. See the gettext manual, section Names.\"']) - AM_][XGETTEXT_OPTION([--keyword='proper_name_utf8:1,\"This is a proper name. See the gettext manual, section Names.\"'])]) - gl_FUNC_RAISE - gl_CONDITIONAL([GL_COND_OBJ_RAISE], - [test $HAVE_RAISE = 0 || test $REPLACE_RAISE = 1]) - AM_COND_IF([GL_COND_OBJ_RAISE], [ - gl_PREREQ_RAISE - ]) - gl_SIGNAL_MODULE_INDICATOR([raise]) - gl_FUNC_RAWMEMCHR - gl_CONDITIONAL([GL_COND_OBJ_RAWMEMCHR], [test $HAVE_RAWMEMCHR = 0]) - AM_COND_IF([GL_COND_OBJ_RAWMEMCHR], [ - gl_PREREQ_RAWMEMCHR - ]) - gl_STRING_MODULE_INDICATOR([rawmemchr]) - gl_FUNC_READLINK - gl_CONDITIONAL([GL_COND_OBJ_READLINK], - [test $HAVE_READLINK = 0 || test $REPLACE_READLINK = 1]) - AM_COND_IF([GL_COND_OBJ_READLINK], [ - gl_PREREQ_READLINK - ]) - gl_UNISTD_MODULE_INDICATOR([readlink]) - gl_FUNC_REALLOC_GNU - if test $REPLACE_REALLOC_FOR_REALLOC_GNU = 1; then - AC_LIBOBJ([realloc]) - fi - gl_STDLIB_MODULE_INDICATOR([realloc-gnu]) - gl_FUNC_REALLOC_POSIX - if test $REPLACE_REALLOC_FOR_REALLOC_POSIX = 1; then - AC_LIBOBJ([realloc]) - fi - gl_STDLIB_MODULE_INDICATOR([realloc-posix]) - gl_FUNC_REALLOCARRAY - gl_CONDITIONAL([GL_COND_OBJ_REALLOCARRAY], - [test $HAVE_REALLOCARRAY = 0 || test $REPLACE_REALLOCARRAY = 1]) - AM_COND_IF([GL_COND_OBJ_REALLOCARRAY], [ - gl_PREREQ_REALLOCARRAY - ]) - gl_MODULE_INDICATOR([reallocarray]) - gl_STDLIB_MODULE_INDICATOR([reallocarray]) - gl_RELOCATABLE([$gl_source_base]) - gl_CONDITIONAL([GL_COND_OBJ_PROGRELOC], [test $RELOCATABLE = yes]) - AM_COND_IF([GL_COND_OBJ_PROGRELOC], [ - AC_LIBOBJ([relocatable]) - ]) - AC_REQUIRE([AC_C_RESTRICT]) - gl_FUNC_READLINK_SEPARATE - gl_CANONICALIZE_LGPL_SEPARATE - gl_FUNC_MALLOC_POSIX - gl_FUNC_REALLOC_POSIX - gl_FUNC_FREE - gl_FUNC_MEMPCPY - gl_FUNC_RAWMEMCHR - gl_MALLOCA - gl_RELOCATABLE_LIBRARY - gl_FUNC_SETENV_SEPARATE - gl_FUNC_SETLOCALE - gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE], [test $REPLACE_SETLOCALE = 1]) - AM_COND_IF([GL_COND_OBJ_SETLOCALE], [ - gl_PREREQ_SETLOCALE - ]) - gl_LOCALE_MODULE_INDICATOR([setlocale]) - gl_FUNC_SETLOCALE_NULL - gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE_LOCK], - [test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0]) - AM_COND_IF([GL_COND_OBJ_SETLOCALE_LOCK], [ - gl_PREREQ_SETLOCALE_LOCK - ]) - gl_LOCALE_MODULE_INDICATOR([setlocale_null]) - gl_SIGNAL_H - gl_SIGNAL_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_SIGNAL_SIGPIPE - dnl Define the C macro GNULIB_SIGPIPE to 1. - gl_MODULE_INDICATOR([sigpipe]) - dnl Define the substituted variable GNULIB_SIGNAL_H_SIGPIPE to 1. - gl_SIGNAL_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE], [1]) - dnl Define the substituted variable GNULIB_STDIO_H_SIGPIPE to 1. - gl_STDIO_H_REQUIRE_DEFAULTS - AC_REQUIRE([gl_ASM_SYMBOL_PREFIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE], [1]) - dnl Define the substituted variable GNULIB_UNISTD_H_SIGPIPE to 1. - gl_UNISTD_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE], [1]) - gl_SIGNALBLOCKING - gl_CONDITIONAL([GL_COND_OBJ_SIGPROCMASK], [test $HAVE_POSIX_SIGNALBLOCKING = 0]) - AM_COND_IF([GL_COND_OBJ_SIGPROCMASK], [ - gl_PREREQ_SIGPROCMASK - ]) - gl_SIGNAL_MODULE_INDICATOR([sigprocmask]) - gt_TYPE_SSIZE_T - gl_FUNC_STAT - gl_CONDITIONAL([GL_COND_OBJ_STAT], [test $REPLACE_STAT = 1]) - AM_COND_IF([GL_COND_OBJ_STAT], [ - case "$host_os" in - mingw* | windows*) - AC_LIBOBJ([stat-w32]) - ;; - esac - gl_PREREQ_STAT - ]) - gl_SYS_STAT_MODULE_INDICATOR([stat]) - gl_STAT_TIME - gl_STAT_BIRTHTIME - gl_C_BOOL - AC_CHECK_HEADERS_ONCE([stdckdint.h]) - if test $ac_cv_header_stdckdint_h = yes; then - GL_GENERATE_STDCKDINT_H=false - else - GL_GENERATE_STDCKDINT_H=true - fi - gl_CONDITIONAL_HEADER([stdckdint.h]) - AC_PROG_MKDIR_P - gl_STDDEF_H - gl_STDDEF_H_REQUIRE_DEFAULTS - gl_CONDITIONAL_HEADER([stddef.h]) - AC_PROG_MKDIR_P - gl_STDINT_H - gl_CONDITIONAL_HEADER([stdint.h]) - dnl Because of gl_REPLACE_LIMITS_H: - gl_CONDITIONAL_HEADER([limits.h]) - AC_PROG_MKDIR_P - gl_STDIO_H - gl_STDIO_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_CONDITIONAL([GL_COND_OBJ_STDIO_READ], [test $REPLACE_STDIO_READ_FUNCS = 1]) - gl_CONDITIONAL([GL_COND_OBJ_STDIO_WRITE], [test $REPLACE_STDIO_WRITE_FUNCS = 1]) - dnl No need to create extra modules for these functions. Everyone who uses - dnl likely needs them. - gl_STDIO_MODULE_INDICATOR([fscanf]) - gl_MODULE_INDICATOR([fscanf]) - gl_STDIO_MODULE_INDICATOR([scanf]) - gl_MODULE_INDICATOR([scanf]) - gl_STDIO_MODULE_INDICATOR([fgetc]) - gl_STDIO_MODULE_INDICATOR([getc]) - gl_STDIO_MODULE_INDICATOR([getchar]) - gl_STDIO_MODULE_INDICATOR([fgets]) - gl_STDIO_MODULE_INDICATOR([fread]) - dnl No need to create extra modules for these functions. Everyone who uses - dnl likely needs them. - gl_STDIO_MODULE_INDICATOR([fprintf]) - gl_STDIO_MODULE_INDICATOR([printf]) - gl_STDIO_MODULE_INDICATOR([vfprintf]) - gl_STDIO_MODULE_INDICATOR([vprintf]) - gl_STDIO_MODULE_INDICATOR([fputc]) - gl_STDIO_MODULE_INDICATOR([putc]) - gl_STDIO_MODULE_INDICATOR([putchar]) - gl_STDIO_MODULE_INDICATOR([fputs]) - gl_STDIO_MODULE_INDICATOR([puts]) - gl_STDIO_MODULE_INDICATOR([fwrite]) - gl_STDLIB_H - gl_STDLIB_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_FUNC_STRERROR - gl_CONDITIONAL([GL_COND_OBJ_STRERROR], [test $REPLACE_STRERROR = 1]) - gl_MODULE_INDICATOR([strerror]) - gl_STRING_MODULE_INDICATOR([strerror]) - AC_REQUIRE([gl_HEADER_ERRNO_H]) - AC_REQUIRE([gl_FUNC_STRERROR_0]) - gl_CONDITIONAL([GL_COND_OBJ_STRERROR_OVERRIDE], - [test -n "$ERRNO_H" || test $REPLACE_STRERROR_0 = 1]) - AM_COND_IF([GL_COND_OBJ_STRERROR_OVERRIDE], [ - gl_PREREQ_SYS_H_WINSOCK2 - ]) - if test $gl_cond_libtool = false; then - gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV" - gl_libdeps="$gl_libdeps $LIBICONV" - fi - gl_STRING_H - gl_STRING_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_FUNC_STRNLEN - gl_CONDITIONAL([GL_COND_OBJ_STRNLEN], - [test $HAVE_DECL_STRNLEN = 0 || test $REPLACE_STRNLEN = 1]) - AM_COND_IF([GL_COND_OBJ_STRNLEN], [ - gl_PREREQ_STRNLEN - ]) - gl_STRING_MODULE_INDICATOR([strnlen]) - gl_FUNC_STRTOUL - gl_CONDITIONAL([GL_COND_OBJ_STRTOUL], - [test $HAVE_STRTOUL = 0 || test $REPLACE_STRTOUL = 1]) - gl_STDLIB_MODULE_INDICATOR([strtoul]) - gl_SYS_STAT_H - gl_SYS_STAT_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_SYS_TYPES_H - gl_SYS_TYPES_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - AC_CHECK_HEADERS([sys/single_threaded.h]) - AC_REQUIRE([gl_THREADLIB]) - gl_TIME_H - gl_TIME_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_UCHAR_H - gl_UCHAR_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_LIBUNISTRING_LIBHEADER([1.2], [unicase.h]) - gl_UNICASE_H - gl_UNICASE_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_LIBUNISTRING_MODULE([0.9.11], [unicase/tolower]) - gl_LIBUNISTRING_LIBHEADER([1.2], [unictype.h]) - gl_UNICTYPE_H - gl_UNICTYPE_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-alnum]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-alpha]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-blank]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-cntrl]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-digit]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-graph]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.11], [unictype/ctype-lower]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-print]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-punct]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-space]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.11], [unictype/ctype-upper]) - AC_REQUIRE([AC_C_INLINE]) - gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-xdigit]) - gl_LIBUNISTRING_LIBHEADER([1.2], [uninorm.h]) - gl_UNINORM_H - gl_UNINORM_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_UNISTD_H - gl_UNISTD_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_LIBUNISTRING_LIBHEADER([1.2], [unistr.h]) - AC_PROG_MKDIR_P - gl_MODULE_INDICATOR([unistr/u8-mbtoucr]) - gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-mbtoucr]) - gl_MODULE_INDICATOR([unistr/u8-uctomb]) - gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-uctomb]) - gl_LIBUNISTRING_LIBHEADER([0.9.11], [unitypes.h]) - AC_PROG_MKDIR_P - AH_VERBATIM([unitypes_restrict], [ - /* This definition is a duplicate of the one in unitypes.h. - It is here so that we can cope with an older version of unitypes.h - that does not contain this definition and that is pre-installed among - the public header files. */ - # if defined __restrict \ - || 2 < __GNUC__ + (95 <= __GNUC_MINOR__) \ - || __clang_major__ >= 3 - # define _UC_RESTRICT __restrict - # elif 199901L <= __STDC_VERSION__ || defined restrict - # define _UC_RESTRICT restrict - # else - # define _UC_RESTRICT - # endif - ]) - gl_LIBUNISTRING_LIBHEADER([0.9.11], [uniwidth.h]) - AC_PROG_MKDIR_P - gl_LIBUNISTRING_MODULE([1.2], [uniwidth/width]) - AC_DEFINE([GNULIB_STDIO_SINGLE_THREAD], [1], - [Define to 1 if you want the FILE stream functions getc, putc, etc. - to use unlocked I/O if available, throughout the package. - Unlocked I/O can improve performance, sometimes dramatically. - But unlocked I/O is safe only in single-threaded programs, - as well as in multithreaded programs for which you can guarantee that - every FILE stream, including stdin, stdout, stderr, is used only - in a single thread.]) - AC_DEFINE([USE_UNLOCKED_IO], [GNULIB_STDIO_SINGLE_THREAD], - [An alias of GNULIB_STDIO_SINGLE_THREAD.]) - gl_FUNC_GLIBC_UNLOCKED_IO - AC_C_VARARRAYS - gl_WCHAR_H - gl_WCHAR_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_WCTYPE_H - gl_WCTYPE_H_REQUIRE_DEFAULTS - AC_PROG_MKDIR_P - gl_FUNC_WCWIDTH - gl_CONDITIONAL([GL_COND_OBJ_WCWIDTH], - [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]) - AM_COND_IF([GL_COND_OBJ_WCWIDTH], [ - gl_PREREQ_WCWIDTH - ]) - gl_WCHAR_MODULE_INDICATOR([wcwidth]) - AC_REQUIRE([AC_CANONICAL_HOST]) - gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_MUTEX], - [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) - AC_REQUIRE([AC_CANONICAL_HOST]) - gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_ONCE], - [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) - AC_REQUIRE([AC_CANONICAL_HOST]) - gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RECMUTEX], - [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) - AC_REQUIRE([AC_CANONICAL_HOST]) - gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RWLOCK], - [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) - gl_XALLOC - gl_MODULE_INDICATOR([xalloc]) - gl_MODULE_INDICATOR([xalloc-die]) - # End of code from modules - m4_ifval(gl_LIBSOURCES_LIST, [ - m4_syscmd([test ! -d ]m4_defn([gl_LIBSOURCES_DIR])[ || - for gl_file in ]gl_LIBSOURCES_LIST[ ; do - if test ! -r ]m4_defn([gl_LIBSOURCES_DIR])[/$gl_file ; then - echo "missing file ]m4_defn([gl_LIBSOURCES_DIR])[/$gl_file" >&2 - exit 1 - fi - done])dnl - m4_if(m4_sysval, [0], [], - [AC_FATAL([expected source file, required through AC_LIBSOURCES, not found])]) - ]) - m4_popdef([GL_MODULE_INDICATOR_PREFIX]) - m4_popdef([GL_MACRO_PREFIX]) - m4_popdef([gl_LIBSOURCES_DIR]) - m4_popdef([gl_LIBSOURCES_LIST]) - m4_popdef([AC_LIBSOURCES]) - m4_popdef([AC_REPLACE_FUNCS]) - m4_popdef([AC_LIBOBJ]) - AC_CONFIG_COMMANDS_PRE([ - gl_libobjs= - gl_ltlibobjs= - gl_libobjdeps= - if test -n "$gl_LIBOBJS"; then - # Remove the extension. -changequote(,)dnl - sed_drop_objext='s/\.o$//;s/\.obj$//' - sed_dirname1='s,//*,/,g' - sed_dirname2='s,\(.\)/$,\1,' - sed_dirname3='s,^[^/]*$,.,' - sed_dirname4='s,\(.\)/[^/]*$,\1,' - sed_basename1='s,.*/,,' -changequote([, ])dnl - for i in `for i in $gl_LIBOBJS; do echo "$i"; done | sed -e "$sed_drop_objext" | sort | uniq`; do - gl_libobjs="$gl_libobjs $i.$ac_objext" - gl_ltlibobjs="$gl_ltlibobjs $i.lo" - i_dir=`echo "$i" | sed -e "$sed_dirname1" -e "$sed_dirname2" -e "$sed_dirname3" -e "$sed_dirname4"` - i_base=`echo "$i" | sed -e "$sed_basename1"` - gl_libobjdeps="$gl_libobjdeps $i_dir/\$(DEPDIR)/$i_base.Po" - done - fi - AC_SUBST([gl_LIBOBJS], [$gl_libobjs]) - AC_SUBST([gl_LTLIBOBJS], [$gl_ltlibobjs]) - AC_SUBST([gl_LIBOBJDEPS], [$gl_libobjdeps]) - ]) - gltests_libdeps= - gltests_ltlibdeps= - m4_pushdef([AC_LIBOBJ], m4_defn([gltests_LIBOBJ])) - m4_pushdef([AC_REPLACE_FUNCS], m4_defn([gltests_REPLACE_FUNCS])) - m4_pushdef([AC_LIBSOURCES], m4_defn([gltests_LIBSOURCES])) - m4_pushdef([gltests_LIBSOURCES_LIST], []) - m4_pushdef([gltests_LIBSOURCES_DIR], []) - m4_pushdef([GL_MACRO_PREFIX], [gltests]) - m4_pushdef([GL_MODULE_INDICATOR_PREFIX], [GL]) - gl_COMMON - gl_source_base='tests' - gl_source_base_prefix= -changequote(,)dnl - gltests_WITNESS=IN_`echo "${PACKAGE-$PACKAGE_TARNAME}" | LC_ALL=C tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ | LC_ALL=C sed -e 's/[^A-Z0-9_]/_/g'`_GNULIB_TESTS -changequote([, ])dnl - AC_SUBST([gltests_WITNESS]) - gl_module_indicator_condition=$gltests_WITNESS - m4_pushdef([gl_MODULE_INDICATOR_CONDITION], [$gl_module_indicator_condition]) - m4_popdef([gl_MODULE_INDICATOR_CONDITION]) - m4_ifval(gltests_LIBSOURCES_LIST, [ - m4_syscmd([test ! -d ]m4_defn([gltests_LIBSOURCES_DIR])[ || - for gl_file in ]gltests_LIBSOURCES_LIST[ ; do - if test ! -r ]m4_defn([gltests_LIBSOURCES_DIR])[/$gl_file ; then - echo "missing file ]m4_defn([gltests_LIBSOURCES_DIR])[/$gl_file" >&2 - exit 1 - fi - done])dnl - m4_if(m4_sysval, [0], [], - [AC_FATAL([expected source file, required through AC_LIBSOURCES, not found])]) - ]) - m4_popdef([GL_MODULE_INDICATOR_PREFIX]) - m4_popdef([GL_MACRO_PREFIX]) - m4_popdef([gltests_LIBSOURCES_DIR]) - m4_popdef([gltests_LIBSOURCES_LIST]) - m4_popdef([AC_LIBSOURCES]) - m4_popdef([AC_REPLACE_FUNCS]) - m4_popdef([AC_LIBOBJ]) - AC_CONFIG_COMMANDS_PRE([ - gltests_libobjs= - gltests_ltlibobjs= - gltests_libobjdeps= - if test -n "$gltests_LIBOBJS"; then - # Remove the extension. -changequote(,)dnl - sed_drop_objext='s/\.o$//;s/\.obj$//' - sed_dirname1='s,//*,/,g' - sed_dirname2='s,\(.\)/$,\1,' - sed_dirname3='s,^[^/]*$,.,' - sed_dirname4='s,\(.\)/[^/]*$,\1,' - sed_basename1='s,.*/,,' -changequote([, ])dnl - for i in `for i in $gltests_LIBOBJS; do echo "$i"; done | sed -e "$sed_drop_objext" | sort | uniq`; do - gltests_libobjs="$gltests_libobjs $i.$ac_objext" - gltests_ltlibobjs="$gltests_ltlibobjs $i.lo" - i_dir=`echo "$i" | sed -e "$sed_dirname1" -e "$sed_dirname2" -e "$sed_dirname3" -e "$sed_dirname4"` - i_base=`echo "$i" | sed -e "$sed_basename1"` - gltests_libobjdeps="$gltests_libobjdeps $i_dir/\$(DEPDIR)/$i_base.Po" - done - fi - AC_SUBST([gltests_LIBOBJS], [$gltests_libobjs]) - AC_SUBST([gltests_LTLIBOBJS], [$gltests_ltlibobjs]) - AC_SUBST([gltests_LIBOBJDEPS], [$gltests_libobjdeps]) - ]) - AC_REQUIRE([gl_CC_GNULIB_WARNINGS]) - LIBGRT_LIBDEPS="$gl_libdeps" - AC_SUBST([LIBGRT_LIBDEPS]) - LIBGRT_LTLIBDEPS="$gl_ltlibdeps" - AC_SUBST([LIBGRT_LTLIBDEPS]) -]) -m4trace:gnulib-m4/gnulib-comp.m4:1048: -1- AC_DEFUN([gl_LIBOBJ], [ - AS_LITERAL_IF([$1], [gl_LIBSOURCES([$1.c])])dnl - gl_LIBOBJS="$gl_LIBOBJS $1.$ac_objext" -]) -m4trace:gnulib-m4/gnulib-comp.m4:1055: -1- AC_DEFUN([gl_REPLACE_FUNCS], [ - m4_foreach_w([gl_NAME], [$1], [AC_LIBSOURCES(gl_NAME[.c])])dnl - AC_CHECK_FUNCS([$1], , [gl_LIBOBJ($ac_func)]) -]) -m4trace:gnulib-m4/gnulib-comp.m4:1064: -1- AC_DEFUN([gl_LIBSOURCES], [ - m4_foreach([_gl_NAME], [$1], [ - m4_if(_gl_NAME, [alloca.c], [], [ - m4_define([gl_LIBSOURCES_DIR], [gnulib-lib]) - m4_append([gl_LIBSOURCES_LIST], _gl_NAME, [ ]) - ]) - ]) -]) -m4trace:gnulib-m4/gnulib-comp.m4:1075: -1- AC_DEFUN([gltests_LIBOBJ], [ - AS_LITERAL_IF([$1], [gltests_LIBSOURCES([$1.c])])dnl - gltests_LIBOBJS="$gltests_LIBOBJS $1.$ac_objext" -]) -m4trace:gnulib-m4/gnulib-comp.m4:1082: -1- AC_DEFUN([gltests_REPLACE_FUNCS], [ - m4_foreach_w([gl_NAME], [$1], [AC_LIBSOURCES(gl_NAME[.c])])dnl - AC_CHECK_FUNCS([$1], , [gltests_LIBOBJ($ac_func)]) -]) -m4trace:gnulib-m4/gnulib-comp.m4:1091: -1- AC_DEFUN([gltests_LIBSOURCES], [ - m4_foreach([_gl_NAME], [$1], [ - m4_if(_gl_NAME, [alloca.c], [], [ - m4_define([gltests_LIBSOURCES_DIR], [tests]) - m4_append([gltests_LIBSOURCES_LIST], _gl_NAME, [ ]) - ]) - ]) -]) -m4trace:gnulib-m4/gnulib-comp.m4:1102: -1- AC_DEFUN([gl_FILE_LIST], [ - build-aux/config.libpath - build-aux/config.rpath - build-aux/csharpcomp.sh.in - build-aux/install-reloc - build-aux/javacomp.sh.in - build-aux/libtool-reloc - build-aux/reloc-ldflags - doc/relocatable.texi - lib/_Noreturn.h - lib/alloca.in.h - lib/allocator.c - lib/allocator.h - lib/areadlink.c - lib/areadlink.h - lib/arg-nonnull.h - lib/assert.in.h - lib/atexit.c - lib/attribute.h - lib/basename-lgpl.c - lib/basename-lgpl.h - lib/binary-io.c - lib/binary-io.h - lib/c++defs.h - lib/c-ctype.c - lib/c-ctype.h - lib/c-strcase.h - lib/c-strcasecmp.c - lib/c-strncasecmp.c - lib/c32is-impl.h - lib/c32isalnum.c - lib/c32isalpha.c - lib/c32isblank.c - lib/c32iscntrl.c - lib/c32isdigit.c - lib/c32isgraph.c - lib/c32islower.c - lib/c32isprint.c - lib/c32ispunct.c - lib/c32isspace.c - lib/c32isupper.c - lib/c32isxdigit.c - lib/c32to-impl.h - lib/c32tolower.c - lib/c32width.c - lib/calloc.c - lib/canonicalize-lgpl.c - lib/careadlinkat.c - lib/careadlinkat.h - lib/cdefs.h - lib/cloexec.c - lib/cloexec.h - lib/close.c - lib/closeout.c - lib/closeout.h - lib/dup2.c - lib/eloop-threshold.h - lib/errno.in.h - lib/error.c - lib/error.in.h - lib/exitfail.c - lib/exitfail.h - lib/fcntl.c - lib/fcntl.in.h - lib/fd-hook.c - lib/fd-hook.h - lib/filename.h - lib/flexmember.h - lib/free.c - lib/fstat.c - lib/fwriteerror.c - lib/fwriteerror.h - lib/getdtablesize.c - lib/getopt-cdefs.in.h - lib/getopt-core.h - lib/getopt-ext.h - lib/getopt-pfx-core.h - lib/getopt-pfx-ext.h - lib/getopt.c - lib/getopt.in.h - lib/getopt1.c - lib/getopt_int.h - lib/getprogname.c - lib/getprogname.h - lib/gettext.h - lib/glthread/lock.c - lib/glthread/lock.h - lib/glthread/threadlib.c - lib/hard-locale.c - lib/hard-locale.h - lib/ialloc.c - lib/ialloc.h - lib/iconv.c - lib/iconv.in.h - lib/iconv_close.c - lib/iconv_open-aix.gperf - lib/iconv_open-hpux.gperf - lib/iconv_open-irix.gperf - lib/iconv_open-osf.gperf - lib/iconv_open-solaris.gperf - lib/iconv_open-zos.gperf - lib/iconv_open.c - lib/idx.h - lib/intprops-internal.h - lib/intprops.h - lib/inttypes.in.h - lib/iswblank.c - lib/iswdigit.c - lib/iswpunct.c - lib/iswxdigit.c - lib/langinfo.in.h - lib/lc-charset-dispatch.c - lib/lc-charset-dispatch.h - lib/libc-config.h - lib/limits.in.h - lib/localcharset.c - lib/localcharset.h - lib/locale.in.h - lib/localename-table.c - lib/localename-table.h - lib/localename-unsafe.c - lib/localename.c - lib/localename.h - lib/malloc.c - lib/malloc/scratch_buffer.h - lib/malloc/scratch_buffer_grow.c - lib/malloc/scratch_buffer_grow_preserve.c - lib/malloc/scratch_buffer_set_array_size.c - lib/malloca.c - lib/malloca.h - lib/mbchar.c - lib/mbchar.h - lib/mbrtoc32.c - lib/mbrtowc-impl-utf8.h - lib/mbrtowc-impl.h - lib/mbrtowc.c - lib/mbsinit.c - lib/mbslen.c - lib/mbsstr.c - lib/mbszero.c - lib/mbtowc-lock.c - lib/mbtowc-lock.h - lib/mbuiter.c - lib/mbuiter.h - lib/mbuiterf.c - lib/mbuiterf.h - lib/memchr.c - lib/memchr.valgrind - lib/memmove.c - lib/mempcpy.c - lib/minmax.h - lib/msvc-inval.c - lib/msvc-inval.h - lib/msvc-nothrow.c - lib/msvc-nothrow.h - lib/noreturn.h - lib/open.c - lib/pathmax.h - lib/progname.c - lib/progname.h - lib/progreloc.c - lib/propername.c - lib/propername.h - lib/raise.c - lib/rawmemchr.c - lib/rawmemchr.valgrind - lib/readlink.c - lib/realloc.c - lib/reallocarray.c - lib/relocatable.c - lib/relocatable.h - lib/relocwrapper.c - lib/scratch_buffer.h - lib/setenv.c - lib/setlocale-lock.c - lib/setlocale.c - lib/setlocale_null-unlocked.c - lib/setlocale_null.c - lib/setlocale_null.h - lib/signal.in.h - lib/sigprocmask.c - lib/stat-time.c - lib/stat-time.h - lib/stat-w32.c - lib/stat-w32.h - lib/stat.c - lib/stdckdint.in.h - lib/stddef.in.h - lib/stdint.in.h - lib/stdio-read.c - lib/stdio-write.c - lib/stdio.in.h - lib/stdlib.in.h - lib/str-kmp.h - lib/streq.h - lib/strerror-override.c - lib/strerror-override.h - lib/strerror.c - lib/striconv.c - lib/striconv.h - lib/string.in.h - lib/strnlen.c - lib/strnlen1.c - lib/strnlen1.h - lib/strtol.c - lib/strtoul.c - lib/struniq.h - lib/sys_stat.in.h - lib/sys_types.in.h - lib/thread-optim.h - lib/time.in.h - lib/trim.c - lib/trim.h - lib/uchar.in.h - lib/unicase.in.h - lib/unicase/simple-mapping.h - lib/unicase/tolower.c - lib/unicase/tolower.h - lib/unictype.in.h - lib/unictype/bitmap.h - lib/unictype/ctype_alnum.c - lib/unictype/ctype_alnum.h - lib/unictype/ctype_alpha.c - lib/unictype/ctype_alpha.h - lib/unictype/ctype_blank.c - lib/unictype/ctype_blank.h - lib/unictype/ctype_cntrl.c - lib/unictype/ctype_cntrl.h - lib/unictype/ctype_digit.c - lib/unictype/ctype_digit.h - lib/unictype/ctype_graph.c - lib/unictype/ctype_graph.h - lib/unictype/ctype_lower.c - lib/unictype/ctype_lower.h - lib/unictype/ctype_print.c - lib/unictype/ctype_print.h - lib/unictype/ctype_punct.c - lib/unictype/ctype_punct.h - lib/unictype/ctype_space.c - lib/unictype/ctype_space.h - lib/unictype/ctype_upper.c - lib/unictype/ctype_upper.h - lib/unictype/ctype_xdigit.c - lib/unictype/ctype_xdigit.h - lib/uninorm.in.h - lib/unistd.c - lib/unistd.in.h - lib/unistr.in.h - lib/unistr/u8-mbtoucr.c - lib/unistr/u8-uctomb-aux.c - lib/unistr/u8-uctomb.c - lib/unitypes.in.h - lib/uniwidth.in.h - lib/uniwidth/cjk.h - lib/uniwidth/width.c - lib/uniwidth/width0.h - lib/uniwidth/width2.h - lib/unlocked-io.h - lib/verify.h - lib/warn-on-use.h - lib/wchar.in.h - lib/wctype-h.c - lib/wctype.in.h - lib/wcwidth.c - lib/windows-initguard.h - lib/windows-mutex.c - lib/windows-mutex.h - lib/windows-once.c - lib/windows-once.h - lib/windows-recmutex.c - lib/windows-recmutex.h - lib/windows-rwlock.c - lib/windows-rwlock.h - lib/xalloc-die.c - lib/xalloc-oversized.h - lib/xalloc.h - lib/xmalloc.c - lib/xreadlink.c - lib/xreadlink.h - lib/xstriconv.c - lib/xstriconv.h - m4/00gnulib.m4 - m4/__inline.m4 - m4/absolute-header.m4 - m4/alloca.m4 - m4/ansi-c++.m4 - m4/asm-underscore.m4 - m4/assert_h.m4 - m4/atexit.m4 - m4/builtin-expect.m4 - m4/c-bool.m4 - m4/calloc.m4 - m4/canonicalize.m4 - m4/close.m4 - m4/codeset.m4 - m4/csharp.m4 - m4/csharpcomp.m4 - m4/double-slash-root.m4 - m4/dup2.m4 - m4/eealloc.m4 - m4/environ.m4 - m4/errno_h.m4 - m4/error.m4 - m4/error_h.m4 - m4/extensions.m4 - m4/extern-inline.m4 - m4/fcntl-o.m4 - m4/fcntl.m4 - m4/fcntl_h.m4 - m4/flexmember.m4 - m4/free.m4 - m4/fstat.m4 - m4/getdtablesize.m4 - m4/getopt.m4 - m4/getprogname.m4 - m4/gnulib-common.m4 - m4/host-cpu-c-abi.m4 - m4/iconv.m4 - m4/iconv_h.m4 - m4/iconv_open.m4 - m4/include_next.m4 - m4/inline.m4 - m4/intl-thread-locale.m4 - m4/intlmacosx.m4 - m4/inttypes.m4 - m4/iswblank.m4 - m4/iswdigit.m4 - m4/iswpunct.m4 - m4/iswxdigit.m4 - m4/java.m4 - m4/javacomp.m4 - m4/langinfo_h.m4 - m4/largefile.m4 - m4/lcmessage.m4 - m4/lib-ld.m4 - m4/lib-link.m4 - m4/lib-prefix.m4 - m4/libunistring-base.m4 - m4/limits-h.m4 - m4/localcharset.m4 - m4/locale-fr.m4 - m4/locale-ja.m4 - m4/locale-zh.m4 - m4/locale_h.m4 - m4/localename.m4 - m4/lock.m4 - m4/lstat.m4 - m4/malloc.m4 - m4/malloca.m4 - m4/manywarnings-c++.m4 - m4/manywarnings.m4 - m4/mbchar.m4 - m4/mbiter.m4 - m4/mbrtoc32.m4 - m4/mbrtowc.m4 - m4/mbsinit.m4 - m4/mbslen.m4 - m4/mbstate_t.m4 - m4/memchr.m4 - m4/memmove.m4 - m4/mempcpy.m4 - m4/minmax.m4 - m4/mmap-anon.m4 - m4/mode_t.m4 - m4/msvc-inval.m4 - m4/msvc-nothrow.m4 - m4/multiarch.m4 - m4/musl.m4 - m4/nocrash.m4 - m4/off_t.m4 - m4/open-cloexec.m4 - m4/open-slash.m4 - m4/open.m4 - m4/pathmax.m4 - m4/pid_t.m4 - m4/pthread_rwlock_rdlock.m4 - m4/raise.m4 - m4/rawmemchr.m4 - m4/readlink.m4 - m4/realloc.m4 - m4/reallocarray.m4 - m4/relocatable-lib.m4 - m4/relocatable.m4 - m4/setenv.m4 - m4/setlocale.m4 - m4/setlocale_null.m4 - m4/signal_h.m4 - m4/signalblocking.m4 - m4/sigpipe.m4 - m4/ssize_t.m4 - m4/stat-time.m4 - m4/stat.m4 - m4/std-gnu11.m4 - m4/stdalign.m4 - m4/stddef_h.m4 - m4/stdint.m4 - m4/stdio_h.m4 - m4/stdlib_h.m4 - m4/strerror.m4 - m4/string_h.m4 - m4/strnlen.m4 - m4/strtoul.m4 - m4/sys_socket_h.m4 - m4/sys_stat_h.m4 - m4/sys_types_h.m4 - m4/threadlib.m4 - m4/time_h.m4 - m4/uchar_h.m4 - m4/unicase_h.m4 - m4/unictype_h.m4 - m4/uninorm_h.m4 - m4/unistd_h.m4 - m4/unlocked-io.m4 - m4/vararrays.m4 - m4/visibility.m4 - m4/warn-on-use.m4 - m4/warnings.m4 - m4/wchar_h.m4 - m4/wchar_t.m4 - m4/wctype_h.m4 - m4/wcwidth.m4 - m4/wint_t.m4 - m4/xalloc.m4 - m4/zzgnulib.m4 -]) -m4trace:gnulib-m4/host-cpu-c-abi.m4:50: -1- AC_DEFUN([gl_HOST_CPU_C_ABI], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_C_ASM]) - AC_CACHE_CHECK([host CPU and C ABI], [gl_cv_host_cpu_c_abi], - [case "$host_cpu" in - -changequote(,)dnl - i[34567]86 ) -changequote([,])dnl - gl_cv_host_cpu_c_abi=i386 - ;; - - x86_64 ) - # On x86_64 systems, the C compiler may be generating code in one of - # these ABIs: - # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64. - # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64 - # with native Windows (mingw, MSVC). - # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32. - # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if (defined __x86_64__ || defined __amd64__ \ - || defined _M_X64 || defined _M_AMD64) - int ok; - #else - error fail - #endif - ]])], - [AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __ILP32__ || defined _ILP32 - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=x86_64-x32], - [gl_cv_host_cpu_c_abi=x86_64])], - [gl_cv_host_cpu_c_abi=i386]) - ;; - -changequote(,)dnl - alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] ) -changequote([,])dnl - gl_cv_host_cpu_c_abi=alpha - ;; - - arm* | aarch64 ) - # Assume arm with EABI. - # On arm64 systems, the C compiler may be generating code in one of - # these ABIs: - # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64. - # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32. - # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#ifdef __aarch64__ - int ok; - #else - error fail - #endif - ]])], - [AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __ILP32__ || defined _ILP32 - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=arm64-ilp32], - [gl_cv_host_cpu_c_abi=arm64])], - [# Don't distinguish little-endian and big-endian arm, since they - # don't require different machine code for simple operations and - # since the user can distinguish them through the preprocessor - # defines __ARMEL__ vs. __ARMEB__. - # But distinguish arm which passes floating-point arguments and - # return values in integer registers (r0, r1, ...) - this is - # gcc -mfloat-abi=soft or gcc -mfloat-abi=softfp - from arm which - # passes them in float registers (s0, s1, ...) and double registers - # (d0, d1, ...) - this is gcc -mfloat-abi=hard. GCC 4.6 or newer - # sets the preprocessor defines __ARM_PCS (for the first case) and - # __ARM_PCS_VFP (for the second case), but older GCC does not. - echo 'double ddd; void func (double dd) { ddd = dd; }' > conftest.c - # Look for a reference to the register d0 in the .s file. - AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS $gl_c_asm_opt conftest.c) >/dev/null 2>&1 - if LC_ALL=C grep 'd0,' conftest.$gl_asmext >/dev/null; then - gl_cv_host_cpu_c_abi=armhf - else - gl_cv_host_cpu_c_abi=arm - fi - rm -f conftest* - ]) - ;; - - hppa1.0 | hppa1.1 | hppa2.0* | hppa64 ) - # On hppa, the C compiler may be generating 32-bit code or 64-bit - # code. In the latter case, it defines _LP64 and __LP64__. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#ifdef __LP64__ - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=hppa64], - [gl_cv_host_cpu_c_abi=hppa]) - ;; - - ia64* ) - # On ia64 on HP-UX, the C compiler may be generating 64-bit code or - # 32-bit code. In the latter case, it defines _ILP32. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#ifdef _ILP32 - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=ia64-ilp32], - [gl_cv_host_cpu_c_abi=ia64]) - ;; - - mips* ) - # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this - # at 32. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64) - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=mips64], - [# In the n32 ABI, _ABIN32 is defined, _ABIO32 is not defined (but - # may later get defined by ), and _MIPS_SIM == _ABIN32. - # In the 32 ABI, _ABIO32 is defined, _ABIN32 is not defined (but - # may later get defined by ), and _MIPS_SIM == _ABIO32. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if (_MIPS_SIM == _ABIN32) - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=mipsn32], - [gl_cv_host_cpu_c_abi=mips])]) - ;; - - powerpc* ) - # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD. - # No need to distinguish them here; the caller may distinguish - # them based on the OS. - # On powerpc64 systems, the C compiler may still be generating - # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may - # be generating 64-bit code. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __powerpc64__ || defined __LP64__ - int ok; - #else - error fail - #endif - ]])], - [# On powerpc64, there are two ABIs on Linux: The AIX compatible - # one and the ELFv2 one. The latter defines _CALL_ELF=2. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined _CALL_ELF && _CALL_ELF == 2 - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=powerpc64-elfv2], - [gl_cv_host_cpu_c_abi=powerpc64]) - ], - [gl_cv_host_cpu_c_abi=powerpc]) - ;; - - rs6000 ) - gl_cv_host_cpu_c_abi=powerpc - ;; - - riscv32 | riscv64 ) - # There are 2 architectures (with variants): rv32* and rv64*. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if __riscv_xlen == 64 - int ok; - #else - error fail - #endif - ]])], - [cpu=riscv64], - [cpu=riscv32]) - # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d. - # Size of 'long' and 'void *': - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __LP64__ - int ok; - #else - error fail - #endif - ]])], - [main_abi=lp64], - [main_abi=ilp32]) - # Float ABIs: - # __riscv_float_abi_double: - # 'float' and 'double' are passed in floating-point registers. - # __riscv_float_abi_single: - # 'float' are passed in floating-point registers. - # __riscv_float_abi_soft: - # No values are passed in floating-point registers. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __riscv_float_abi_double - int ok; - #else - error fail - #endif - ]])], - [float_abi=d], - [AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __riscv_float_abi_single - int ok; - #else - error fail - #endif - ]])], - [float_abi=f], - [float_abi='']) - ]) - gl_cv_host_cpu_c_abi="${cpu}-${main_abi}${float_abi}" - ;; - - s390* ) - # On s390x, the C compiler may be generating 64-bit (= s390x) code - # or 31-bit (= s390) code. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __LP64__ || defined __s390x__ - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=s390x], - [gl_cv_host_cpu_c_abi=s390]) - ;; - - sparc | sparc64 ) - # UltraSPARCs running Linux have `uname -m` = "sparc64", but the - # C compiler still generates 32-bit code. - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#if defined __sparcv9 || defined __arch64__ - int ok; - #else - error fail - #endif - ]])], - [gl_cv_host_cpu_c_abi=sparc64], - [gl_cv_host_cpu_c_abi=sparc]) - ;; - - *) - gl_cv_host_cpu_c_abi="$host_cpu" - ;; - esac - ]) - - dnl In most cases, $HOST_CPU and $HOST_CPU_C_ABI are the same. - HOST_CPU=`echo "$gl_cv_host_cpu_c_abi" | sed -e 's/-.*//'` - HOST_CPU_C_ABI="$gl_cv_host_cpu_c_abi" - AC_SUBST([HOST_CPU]) - AC_SUBST([HOST_CPU_C_ABI]) - - # This was - # AC_DEFINE_UNQUOTED([__${HOST_CPU}__]) - # AC_DEFINE_UNQUOTED([__${HOST_CPU_C_ABI}__]) - # earlier, but KAI C++ 3.2d doesn't like this. - sed -e 's/-/_/g' >> confdefs.h < - ]], [iconv iconv_open]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/iconv_h.m4:25: -1- AC_DEFUN([gl_REPLACE_ICONV_H], [ - gl_ICONV_H_REQUIRE_DEFAULTS - GL_GENERATE_ICONV_H=true -]) -m4trace:gnulib-m4/iconv_h.m4:35: -1- AC_DEFUN([gl_ICONV_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_ICONV_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) -]) -m4trace:gnulib-m4/iconv_h.m4:45: -1- AC_DEFUN([gl_ICONV_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_ICONV_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ICONV]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_ICONV_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_ICONV_H_DEFAULTS]) -]) -m4trace:gnulib-m4/iconv_h.m4:54: -1- AC_DEFUN([gl_ICONV_H_DEFAULTS], [ - m4_ifdef([gl_ANSI_CXX], [AC_REQUIRE([gl_ANSI_CXX])]) - dnl Assume proper GNU behavior unless another module says otherwise. - ICONV_CONST=; AC_SUBST([ICONV_CONST]) - REPLACE_ICONV=0; AC_SUBST([REPLACE_ICONV]) - REPLACE_ICONV_OPEN=0; AC_SUBST([REPLACE_ICONV_OPEN]) - REPLACE_ICONV_UTF=0; AC_SUBST([REPLACE_ICONV_UTF]) - GL_GENERATE_ICONV_H=false - m4_ifdef([gl_POSIXCHECK], - [GL_GENERATE_ICONV_H=true], - [if m4_ifdef([gl_ANSI_CXX], [test "$CXX" != no], [false]); then - dnl Override always, to support the C++ GNULIB_NAMESPACE. - GL_GENERATE_ICONV_H=true - fi - ]) -]) -m4trace:gnulib-m4/iconv_open.m4:7: -1- AC_DEFUN([gl_FUNC_ICONV_OPEN], [ - AC_REQUIRE([AM_ICONV]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_ICONV_H_DEFAULTS]) - if test "$am_cv_func_iconv" = yes; then - dnl Provide the override, for the sake of the C++ aliases. - gl_REPLACE_ICONV_H - dnl Test whether iconv_open accepts standardized encoding names. - dnl We know that GNU libiconv and GNU libc do. - AC_EGREP_CPP([gnu_iconv], [ - #include - #if (defined _LIBICONV_VERSION && !(_LIBICONV_VERSION == 0x10b && defined __APPLE__)) \ - || (defined __GLIBC__ && !defined __UCLIBC__) - gnu_iconv - #endif - ], [gl_func_iconv_gnu=yes], [gl_func_iconv_gnu=no]) - if test $gl_func_iconv_gnu = no; then - iconv_flavor= - case "$host_os" in - aix*) iconv_flavor=ICONV_FLAVOR_AIX ;; - irix*) iconv_flavor=ICONV_FLAVOR_IRIX ;; - hpux*) iconv_flavor=ICONV_FLAVOR_HPUX ;; - osf*) iconv_flavor=ICONV_FLAVOR_OSF ;; - solaris*) iconv_flavor=ICONV_FLAVOR_SOLARIS ;; - openedition*) iconv_flavor=ICONV_FLAVOR_ZOS ;; - esac - if test -n "$iconv_flavor"; then - AC_DEFINE_UNQUOTED([ICONV_FLAVOR], [$iconv_flavor], - [Define to a symbolic name denoting the flavor of iconv_open() - implementation.]) - gl_REPLACE_ICONV_OPEN - fi - fi - m4_ifdef([gl_FUNC_ICONV_OPEN_UTF_SUPPORT], [ - gl_FUNC_ICONV_OPEN_UTF_SUPPORT - case "$gl_cv_func_iconv_supports_utf" in - *yes) ;; - *) - REPLACE_ICONV_UTF=1 - AC_DEFINE([REPLACE_ICONV_UTF], [1], - [Define if the iconv() functions are enhanced to handle the UTF-{16,32}{BE,LE} encodings.]) - REPLACE_ICONV=1 - gl_REPLACE_ICONV_OPEN - ;; - esac - ]) - fi -]) -m4trace:gnulib-m4/iconv_open.m4:57: -1- AC_DEFUN([gl_REPLACE_ICONV_OPEN], [ - gl_REPLACE_ICONV_H - REPLACE_ICONV_OPEN=1 -]) -m4trace:gnulib-m4/include_next.m4:36: -1- AC_DEFUN([gl_INCLUDE_NEXT], [ - AC_LANG_PREPROC_REQUIRE() - AC_CACHE_CHECK([whether the preprocessor supports include_next], - [gl_cv_have_include_next], - [rm -rf conftestd1a conftestd1b conftestd2 - mkdir conftestd1a conftestd1b conftestd2 - dnl IBM C 9.0, 10.1 (original versions, prior to the 2009-01 updates) on - dnl AIX 6.1 support include_next when used as first preprocessor directive - dnl in a file, but not when preceded by another include directive. Check - dnl for this bug by including . - dnl Additionally, with this same compiler, include_next is a no-op when - dnl used in a header file that was included by specifying its absolute - dnl file name. Despite these two bugs, include_next is used in the - dnl compiler's . By virtue of the second bug, we need to use - dnl include_next as well in this case. - cat < conftestd1a/conftest.h -#define DEFINED_IN_CONFTESTD1 -#include_next -#ifdef DEFINED_IN_CONFTESTD2 -int foo; -#else -#error "include_next doesn't work" -#endif -EOF - cat < conftestd1b/conftest.h -#define DEFINED_IN_CONFTESTD1 -#include -#include_next -#ifdef DEFINED_IN_CONFTESTD2 -int foo; -#else -#error "include_next doesn't work" -#endif -EOF - cat < conftestd2/conftest.h -#ifndef DEFINED_IN_CONFTESTD1 -#error "include_next test doesn't work" -#endif -#define DEFINED_IN_CONFTESTD2 -EOF - gl_saved_CPPFLAGS="$CPPFLAGS" - CPPFLAGS="$gl_saved_CPPFLAGS -Iconftestd1b -Iconftestd2" -dnl We intentionally avoid using AC_LANG_SOURCE here. - AC_COMPILE_IFELSE([AC_LANG_DEFINES_PROVIDED[#include ]], - [gl_cv_have_include_next=yes], - [CPPFLAGS="$gl_saved_CPPFLAGS -Iconftestd1a -Iconftestd2" - AC_COMPILE_IFELSE([AC_LANG_DEFINES_PROVIDED[#include ]], - [gl_cv_have_include_next=buggy], - [gl_cv_have_include_next=no]) - ]) - CPPFLAGS="$gl_saved_CPPFLAGS" - rm -rf conftestd1a conftestd1b conftestd2 - ]) - PRAGMA_SYSTEM_HEADER= - if test $gl_cv_have_include_next = yes; then - INCLUDE_NEXT=include_next - INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next - if test -n "$GCC"; then - PRAGMA_SYSTEM_HEADER='#pragma GCC system_header' - fi - else - if test $gl_cv_have_include_next = buggy; then - INCLUDE_NEXT=include - INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next - else - INCLUDE_NEXT=include - INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include - fi - fi - AC_SUBST([INCLUDE_NEXT]) - AC_SUBST([INCLUDE_NEXT_AS_FIRST_DIRECTIVE]) - AC_SUBST([PRAGMA_SYSTEM_HEADER]) - - dnl HP NonStop systems, which define __TANDEM, limit the line length - dnl after including some system header files. - AC_CACHE_CHECK([whether source code line length is unlimited], - [gl_cv_source_line_length_unlimited], - [AC_EGREP_CPP([choke me], - [ -#ifdef __TANDEM -choke me -#endif - ], - [gl_cv_source_line_length_unlimited=no], - [gl_cv_source_line_length_unlimited=yes]) - ]) - if test $gl_cv_source_line_length_unlimited = no; then - PRAGMA_COLUMNS="#pragma COLUMNS 10000" - else - PRAGMA_COLUMNS= - fi - AC_SUBST([PRAGMA_COLUMNS]) -]) -m4trace:gnulib-m4/include_next.m4:156: -1- AC_DEFUN([gl_CHECK_NEXT_HEADERS], [ - gl_NEXT_HEADERS_INTERNAL([$1], [check]) -]) -m4trace:gnulib-m4/include_next.m4:166: -1- AC_DEFUN([gl_NEXT_HEADERS], [ - gl_NEXT_HEADERS_INTERNAL([$1], [assume]) -]) -m4trace:gnulib-m4/include_next.m4:172: -1- AC_DEFUN([gl_NEXT_HEADERS_INTERNAL], [ - AC_REQUIRE([gl_INCLUDE_NEXT]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - m4_if([$2], [check], - [AC_CHECK_HEADERS_ONCE([$1]) - ]) - - m4_foreach_w([gl_HEADER_NAME], [$1], - [AS_VAR_PUSHDEF([gl_next_header], - [gl_cv_next_]m4_defn([gl_HEADER_NAME])) - if test $gl_cv_have_include_next = yes; then - AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>']) - else - AC_CACHE_CHECK( - [absolute name of <]m4_defn([gl_HEADER_NAME])[>], - [gl_next_header], - [m4_if([$2], [check], - [AS_VAR_PUSHDEF([gl_header_exists], - [ac_cv_header_]m4_defn([gl_HEADER_NAME])) - if test AS_VAR_GET([gl_header_exists]) = yes; then - AS_VAR_POPDEF([gl_header_exists]) - ]) - gl_ABSOLUTE_HEADER_ONE(gl_HEADER_NAME) - AS_VAR_COPY([gl_header], [gl_cv_absolute_]AS_TR_SH(gl_HEADER_NAME)) - AS_VAR_SET([gl_next_header], ['"'$gl_header'"']) - m4_if([$2], [check], - [else - AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>']) - fi - ]) - ]) - fi - AC_SUBST( - AS_TR_CPP([NEXT_]m4_defn([gl_HEADER_NAME])), - [AS_VAR_GET([gl_next_header])]) - if test $gl_cv_have_include_next = yes || test $gl_cv_have_include_next = buggy; then - # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include_next' - gl_next_as_first_directive='<'gl_HEADER_NAME'>' - else - # INCLUDE_NEXT_AS_FIRST_DIRECTIVE='include' - gl_next_as_first_directive=AS_VAR_GET([gl_next_header]) - fi - AC_SUBST( - AS_TR_CPP([NEXT_AS_FIRST_DIRECTIVE_]m4_defn([gl_HEADER_NAME])), - [$gl_next_as_first_directive]) - AS_VAR_POPDEF([gl_next_header])]) -]) -m4trace:gnulib-m4/inline.m4:12: -1- AC_DEFUN([gl_INLINE], [ - AC_REQUIRE([AC_C_INLINE]) - AC_CACHE_CHECK([whether the compiler generally respects inline], - [gl_cv_c_inline_effective], - [if test $ac_cv_c_inline = no; then - gl_cv_c_inline_effective=no - else - dnl GCC defines __NO_INLINE__ if not optimizing or if -fno-inline is - dnl specified. - dnl Use AC_COMPILE_IFELSE here, not AC_EGREP_CPP, because the result - dnl depends on optimization flags, which can be in CFLAGS. - dnl (AC_EGREP_CPP looks only at the CPPFLAGS.) - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[]], - [[#ifdef __NO_INLINE__ - #error "inline is not effective" - #endif]])], - [gl_cv_c_inline_effective=yes], - [gl_cv_c_inline_effective=no]) - fi - ]) - if test $gl_cv_c_inline_effective = yes; then - AC_DEFINE([HAVE_INLINE], [1], - [Define to 1 if the compiler supports one of the keywords - 'inline', '__inline__', '__inline' and effectively inlines - functions marked as such.]) - fi -]) -m4trace:gnulib-m4/intl-thread-locale.m4:18: -1- AC_DEFUN([gt_INTL_THREAD_LOCALE_NAME], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - - dnl Persuade Solaris to define 'locale_t'. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - dnl Test whether uselocale() exists and works at all. - gt_FUNC_USELOCALE - - dnl On OpenBSD >= 6.2, the locale_t type and the uselocale(), newlocale(), - dnl duplocale(), freelocale() functions exist but are effectively useless, - dnl because the locale_t value depends only on the LC_CTYPE category of the - dnl locale and furthermore contains only one bit of information (it - dnl distinguishes the "C" locale from the *.UTF-8 locales). See - dnl . - dnl In the setlocale() implementation they have thought about the programs - dnl that use the API ("Even though only LC_CTYPE has any effect in the - dnl OpenBSD base system, store complete information about the global locale, - dnl such that third-party software can access it"), but for uselocale() - dnl they did not think about the programs. - dnl In this situation, even the HAVE_NAMELESS_LOCALES support does not work. - dnl So, define HAVE_FAKE_LOCALES and disable all locale_t support. - dnl Expected result: HAVE_FAKE_LOCALES is defined on OpenBSD ≥ 6.2. - case "$gt_cv_func_uselocale_works" in - *yes) - AC_CHECK_HEADERS_ONCE([xlocale.h]) - AC_CACHE_CHECK([for fake locale system (OpenBSD)], - [gt_cv_locale_fake], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#if HAVE_XLOCALE_H -# include -#endif -int main () -{ - locale_t loc1, loc2; - if (setlocale (LC_ALL, "de_DE.UTF-8") == NULL) return 1; - if (setlocale (LC_ALL, "fr_FR.UTF-8") == NULL) return 1; - loc1 = newlocale (LC_ALL_MASK, "de_DE.UTF-8", (locale_t)0); - loc2 = newlocale (LC_ALL_MASK, "fr_FR.UTF-8", (locale_t)0); - return !(loc1 == loc2); -}]])], - [gt_cv_locale_fake=yes], - [gt_cv_locale_fake=no], - [dnl Guess the locale system is fake only on OpenBSD. - case "$host_os" in - openbsd*) gt_cv_locale_fake="guessing yes" ;; - *) gt_cv_locale_fake="guessing no" ;; - esac - ]) - ]) - ;; - *) gt_cv_locale_fake=no ;; - esac - case "$gt_cv_locale_fake" in - *yes) - gt_fake_locales=yes - AC_DEFINE([HAVE_FAKE_LOCALES], [1], - [Define if the locale_t type contains insufficient information, as on OpenBSD.]) - ;; - *) - gt_fake_locales=no - ;; - esac - - dnl Expected result: HAVE_SOLARIS114_LOCALES is defined on Solaris ≥ 11.4. - case "$gt_cv_func_uselocale_works" in - *yes) - AC_CACHE_CHECK([for Solaris 11.4 locale system], - [gt_cv_locale_solaris114], - [case "$host_os" in - solaris*) - dnl Test whether defines locale_t as a typedef of - dnl 'struct _LC_locale_t **' (whereas Illumos defines it as a - dnl typedef of 'struct _locale *'). - dnl Another possible test would be to include - dnl and test whether it defines the _LC_core_data_locale_t type. - dnl This type was added in Solaris 11.4. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #include - struct _LC_locale_t *x; - locale_t y; - ]], - [[*y = x;]])], - [gt_cv_locale_solaris114=yes], - [gt_cv_locale_solaris114=no]) - ;; - *) gt_cv_locale_solaris114=no ;; - esac - ]) - ;; - *) gt_cv_locale_solaris114=no ;; - esac - if test $gt_cv_locale_solaris114 = yes; then - AC_DEFINE([HAVE_SOLARIS114_LOCALES], [1], - [Define if the locale_t type is as on Solaris 11.4.]) - fi - - dnl Solaris 12 will maybe provide getlocalename_l. If it does, it will - dnl improve the implementation of gl_locale_name_thread(), by removing - dnl the use of undocumented structures. - case "$gt_cv_func_uselocale_works" in - *yes) - AC_CHECK_FUNCS([getlocalename_l]) - ;; - esac - - dnl This code is for platforms where the locale_t type does not provide access - dnl to the name of each locale category. This code has the drawback that it - dnl requires the gnulib overrides of 'newlocale', 'duplocale', 'freelocale', - dnl which is a problem for GNU libunistring. Therefore try hard to avoid - dnl enabling this code! - dnl Expected result: HAVE_NAMELESS_LOCALES is defined on AIX, - dnl and HAVE_AIX72_LOCALES is defined on AIX ≥ 7.2. - gt_nameless_locales=no - case "$host_os" in - dnl It's needed on AIX 7.2. - aix*) - gt_nameless_locales=yes - AC_DEFINE([HAVE_NAMELESS_LOCALES], [1], - [Define if the locale_t type does not contain the name of each locale category.]) - dnl In AIX ≥ 7.2, a locale contains at least the name of the LC_MESSSAGES - dnl category (fix of defect 823926). - AC_CACHE_CHECK([for AIX locales with LC_MESSAGES name], - [gt_cv_locale_aix72], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #include - /* Include , which defines __locale_t. */ - #include - locale_t x; - ]], - [[return ((__locale_t) x)->locale_name[0];]])], - [gt_cv_locale_aix72=yes], - [gt_cv_locale_aix72=no]) - ]) - if test $gt_cv_locale_aix72 = yes; then - AC_DEFINE([HAVE_AIX72_LOCALES], [1], - [Define if the __locale_t type contains the name of the LC_MESSAGES category.]) - fi - ;; - esac - - dnl We cannot support uselocale() on platforms where the locale_t type is - dnl fake. So, set - dnl gt_good_uselocale = gt_working_uselocale && !gt_fake_locales. - dnl Expected result: HAVE_GOOD_USELOCALE is defined on all platforms except - dnl FreeBSD < 9.1, NetBSD, OpenBSD, Minix, AIX < 7, AIX 7.2, HP-UX, IRIX, - dnl Solaris < 11.4, Cygwin < 2.6, mingw, MSVC 14, Android API level < 21. - if test $gt_working_uselocale = yes && test $gt_fake_locales = no; then - gt_good_uselocale=yes - AC_DEFINE([HAVE_GOOD_USELOCALE], [1], - [Define if the uselocale function exists, may be safely called, and returns sufficient information.]) - else - gt_good_uselocale=no - fi - - dnl Set gt_localename_enhances_locale_funcs to indicate whether localename.c - dnl overrides newlocale(), duplocale(), freelocale() to keep track of locale - dnl names. - dnl Expected result: LOCALENAME_ENHANCE_LOCALE_FUNCS is defined on - dnl AIX 7.1, AIX ≥ 7.3. - if test $gt_good_uselocale = yes && test $gt_nameless_locales = yes; then - gt_localename_enhances_locale_funcs=yes - LOCALENAME_ENHANCE_LOCALE_FUNCS=1 - AC_DEFINE([LOCALENAME_ENHANCE_LOCALE_FUNCS], [1], - [Define if localename.c overrides newlocale(), duplocale(), freelocale().]) - else - gt_localename_enhances_locale_funcs=no - fi -]) -m4trace:gnulib-m4/intl-thread-locale.m4:198: -1- AC_DEFUN([gt_FUNC_USELOCALE], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - dnl Persuade glibc and Solaris to define 'locale_t'. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - gl_CHECK_FUNCS_ANDROID([uselocale], [[#include ]]) - - dnl On AIX 7.2, the uselocale() function is not documented and leads to - dnl crashes in subsequent setlocale() invocations. - dnl In 2019, some versions of z/OS lack the locale_t type and have a broken - dnl uselocale function. - if test $ac_cv_func_uselocale = yes; then - AC_CHECK_HEADERS_ONCE([xlocale.h]) - AC_CACHE_CHECK([whether uselocale works], - [gt_cv_func_uselocale_works], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#if HAVE_XLOCALE_H -# include -#endif -locale_t loc1; -int main () -{ - uselocale (NULL); - setlocale (LC_ALL, "en_US.UTF-8"); - return 0; -}]])], - [gt_cv_func_uselocale_works=yes], - [gt_cv_func_uselocale_works=no], - [# Guess no on AIX and z/OS, yes otherwise. - case "$host_os" in - aix* | openedition*) gt_cv_func_uselocale_works="guessing no" ;; - *) gt_cv_func_uselocale_works="guessing yes" ;; - esac - ]) - ]) - else - gt_cv_func_uselocale_works=no - fi - case "$gt_cv_func_uselocale_works" in - *yes) - gt_working_uselocale=yes - AC_DEFINE([HAVE_WORKING_USELOCALE], [1], - [Define if the uselocale function exists and may safely be called.]) - ;; - *) - gt_working_uselocale=no - ;; - esac -]) -m4trace:gnulib-m4/inttypes.m4:10: -1- AC_DEFUN_ONCE([gl_INTTYPES_H], [ - AC_REQUIRE([gl_INTTYPES_INCOMPLETE]) - gl_INTTYPES_PRI_SCN -]) -m4trace:gnulib-m4/inttypes.m4:16: -1- AC_DEFUN_ONCE([gl_INTTYPES_INCOMPLETE], [ - AC_REQUIRE([gl_STDINT_H]) - AC_CHECK_HEADERS_ONCE([inttypes.h]) - - dnl Override always, so that the portability warnings work. - AC_REQUIRE([gl_INTTYPES_H_DEFAULTS]) - gl_CHECK_NEXT_HEADERS([inttypes.h]) - - AC_REQUIRE([gl_MULTIARCH]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[#include - ]], [imaxabs imaxdiv strtoimax strtoumax]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/inttypes.m4:36: -1- AC_DEFUN([gl_INTTYPES_PRI_SCN], [ - PRIPTR_PREFIX= - if $GL_GENERATE_STDINT_H; then - dnl Using the gnulib . It defines intptr_t to 'long' or - dnl 'long long', depending on _WIN64. - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #ifdef _WIN64 - LLP64 - #endif - ]]) - ], - [PRIPTR_PREFIX='"l"'], - [PRIPTR_PREFIX='"ll"']) - else - dnl Using the system's . - for glpfx in '' l ll I64; do - case $glpfx in - '') gltype1='int';; - l) gltype1='long int';; - ll) gltype1='long long int';; - I64) gltype1='__int64';; - esac - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include - extern intptr_t foo; - extern $gltype1 foo;]])], - [PRIPTR_PREFIX='"'$glpfx'"']) - test -n "$PRIPTR_PREFIX" && break - done - fi - AC_SUBST([PRIPTR_PREFIX]) - - gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION( - [INT32_MAX_LT_INTMAX_MAX], - [defined INT32_MAX && defined INTMAX_MAX], - [INT32_MAX < INTMAX_MAX], - [sizeof (int) < sizeof (long long int)]) - if test $APPLE_UNIVERSAL_BUILD = 0; then - gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION( - [INT64_MAX_EQ_LONG_MAX], - [defined INT64_MAX], - [INT64_MAX == LONG_MAX], - [sizeof (long long int) == sizeof (long int)]) - else - INT64_MAX_EQ_LONG_MAX=-1 - fi - gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION( - [UINT32_MAX_LT_UINTMAX_MAX], - [defined UINT32_MAX && defined UINTMAX_MAX], - [UINT32_MAX < UINTMAX_MAX], - [sizeof (unsigned int) < sizeof (unsigned long long int)]) - if test $APPLE_UNIVERSAL_BUILD = 0; then - gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION( - [UINT64_MAX_EQ_ULONG_MAX], - [defined UINT64_MAX], - [UINT64_MAX == ULONG_MAX], - [sizeof (unsigned long long int) == sizeof (unsigned long int)]) - else - UINT64_MAX_EQ_ULONG_MAX=-1 - fi -]) -m4trace:gnulib-m4/inttypes.m4:106: -1- AC_DEFUN([gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION], [ - AC_CACHE_CHECK([whether $3], - [gl_cv_test_$1], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[/* Work also in C++ mode. */ - #define __STDC_LIMIT_MACROS 1 - - /* Work if build is not clean. */ - #define _GL_JUST_INCLUDE_SYSTEM_STDINT_H - - #include - #if HAVE_STDINT_H - #include - #endif - - #if $2 - #define CONDITION ($3) - #else - #define CONDITION ($4) - #endif - int test[CONDITION ? 1 : -1];]])], - [gl_cv_test_$1=yes], - [gl_cv_test_$1=no])]) - if test $gl_cv_test_$1 = yes; then - $1=1; - else - $1=0; - fi - AC_SUBST([$1]) -]) -m4trace:gnulib-m4/inttypes.m4:143: -1- AC_DEFUN([gl_INTTYPES_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_INTTYPES_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) -]) -m4trace:gnulib-m4/inttypes.m4:153: -1- AC_DEFUN([gl_INTTYPES_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_INTTYPES_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_IMAXABS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_IMAXDIV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOIMAX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOUMAX]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_INTTYPES_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_INTTYPES_H_DEFAULTS]) -]) -m4trace:gnulib-m4/inttypes.m4:165: -1- AC_DEFUN([gl_INTTYPES_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_DECL_IMAXABS=1; AC_SUBST([HAVE_DECL_IMAXABS]) - HAVE_DECL_IMAXDIV=1; AC_SUBST([HAVE_DECL_IMAXDIV]) - HAVE_DECL_STRTOIMAX=1; AC_SUBST([HAVE_DECL_STRTOIMAX]) - HAVE_DECL_STRTOUMAX=1; AC_SUBST([HAVE_DECL_STRTOUMAX]) - HAVE_IMAXDIV_T=1; AC_SUBST([HAVE_IMAXDIV_T]) - HAVE_IMAXABS=1; AC_SUBST([HAVE_IMAXABS]) - HAVE_IMAXDIV=1; AC_SUBST([HAVE_IMAXDIV]) - REPLACE_IMAXABS=0; AC_SUBST([REPLACE_IMAXABS]) - REPLACE_IMAXDIV=0; AC_SUBST([REPLACE_IMAXDIV]) - REPLACE_STRTOIMAX=0; AC_SUBST([REPLACE_STRTOIMAX]) - REPLACE_STRTOUMAX=0; AC_SUBST([REPLACE_STRTOUMAX]) - INT32_MAX_LT_INTMAX_MAX=1; AC_SUBST([INT32_MAX_LT_INTMAX_MAX]) - INT64_MAX_EQ_LONG_MAX='defined _LP64'; AC_SUBST([INT64_MAX_EQ_LONG_MAX]) - PRIPTR_PREFIX=__PRIPTR_PREFIX; AC_SUBST([PRIPTR_PREFIX]) - UINT32_MAX_LT_UINTMAX_MAX=1; AC_SUBST([UINT32_MAX_LT_UINTMAX_MAX]) - UINT64_MAX_EQ_ULONG_MAX='defined _LP64'; AC_SUBST([UINT64_MAX_EQ_ULONG_MAX]) -]) -m4trace:gnulib-m4/iswblank.m4:7: -1- AC_DEFUN([gl_FUNC_ISWBLANK], [ - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) - AC_REQUIRE([gl_WCTYPE_H]) - dnl Persuade glibc to declare iswblank(). - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - gl_CHECK_FUNCS_ANDROID([iswblank], [[#include ]]) - AC_CHECK_DECLS([iswblank], , , [[ - #include - #include - ]]) - if test $ac_cv_func_iswblank = no; then - HAVE_ISWBLANK=0 - if test $ac_cv_have_decl_iswblank = yes \ - || case "$gl_cv_onwards_func_iswblank" in \ - future*) true ;; \ - *) false ;; \ - esac; then - REPLACE_ISWBLANK=1 - fi - fi - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then - dnl Redefine all of iswcntrl, ..., towupper in . - : - else - if test $HAVE_ISWBLANK = 0 || test $REPLACE_ISWBLANK = 1; then - dnl Redefine only iswblank. - : - fi - fi - -]) -m4trace:gnulib-m4/iswdigit.m4:7: -1- AC_DEFUN([gl_FUNC_ISWDIGIT], [ - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) - AC_REQUIRE([gl_WCTYPE_H]) - AC_REQUIRE([gt_LOCALE_FR]) - AC_REQUIRE([gt_LOCALE_JA]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([gt_LOCALE_ZH_CN]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then - dnl redefines iswdigit already. - REPLACE_ISWDIGIT="$REPLACE_ISWCNTRL" - else - AC_CACHE_CHECK([whether iswdigit is ISO C compliant], - [gl_cv_func_iswdigit_works], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on FreeBSD, NetBSD, Solaris, native Windows. - freebsd* | dragonfly* | netbsd* | solaris* | mingw* | windows*) - gl_cv_func_iswdigit_works="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_iswdigit_works="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_FR != none || test $LOCALE_JA != none || test $LOCALE_FR_UTF8 != none || test $LOCALE_ZH_CN != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include -#include - -/* Returns the value of iswdigit for the multibyte character s[0..n-1]. */ -static int -for_character (const char *s, size_t n) -{ - mbstate_t state; - wchar_t wc; - size_t ret; - - memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; - ret = mbrtowc (&wc, s, n, &state); - if (ret != n) - abort (); - - return iswdigit (wc); -} - -int -main (int argc, char *argv[]) -{ - int is; - int result = 0; - - if (strcmp ("$LOCALE_FR", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_FR") != NULL) - { - /* This fails on mingw, MSVC 14. */ - /* U+00B2 SUPERSCRIPT TWO */ - is = for_character ("\262", 1); - if (!(is == 0)) - result |= 1; - } - if (strcmp ("$LOCALE_JA", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_JA") != NULL) - { - /* This fails on NetBSD 8.0. */ - /* U+FF11 FULLWIDTH DIGIT ONE */ - is = for_character ("\243\261", 2); - if (!(is == 0)) - result |= 2; - } - if (strcmp ("$LOCALE_FR_UTF8", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - /* This fails on FreeBSD 13.0, NetBSD 8.0, MSVC 14. */ - /* U+0663 ARABIC-INDIC DIGIT THREE */ - is = for_character ("\331\243", 2); - if (!(is == 0)) - result |= 4; - /* This fails on FreeBSD 13.0, NetBSD 8.0, MSVC 14. */ - /* U+FF11 FULLWIDTH DIGIT ONE */ - is = for_character ("\357\274\221", 3); - if (!(is == 0)) - result |= 8; - } - if (strcmp ("$LOCALE_ZH_CN", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL) - { - /* This fails on NetBSD 8.0, Solaris 10, Solaris 11.4. */ - /* U+FF11 FULLWIDTH DIGIT ONE */ - is = for_character ("\243\261", 2); - if (!(is == 0)) - result |= 16; - } - return result; -}]])], - [gl_cv_func_iswdigit_works=yes], - [gl_cv_func_iswdigit_works=no], - [:]) - fi - ]) - case "$gl_cv_func_iswdigit_works" in - *yes) ;; - *) REPLACE_ISWDIGIT=1 ;; - esac - fi -]) -m4trace:gnulib-m4/iswpunct.m4:7: -1- AC_DEFUN([gl_FUNC_ISWPUNCT], [ - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) - AC_REQUIRE([gl_WCTYPE_H]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then - dnl redefines iswpunct already. - REPLACE_ISWPUNCT="$REPLACE_ISWCNTRL" - else - AC_CACHE_CHECK([whether iswpunct is consistent with ispunct], - [gl_cv_func_iswpunct_works], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int -main (int argc, char *argv[]) -{ - int result = 0; - /* This fails on Android 11. */ - if ((! iswpunct ('\`')) != (! ispunct ('\`'))) - result |= 1; - return result; -}]])], - [gl_cv_func_iswpunct_works=yes], - [gl_cv_func_iswpunct_works=no], - [case "$host_os" in - # Guess no on Android. - android*) gl_cv_func_iswpunct_works="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_iswpunct_works="guessing yes" ;; - esac - ]) - ]) - case "$gl_cv_func_iswpunct_works" in - *yes) ;; - *) REPLACE_ISWPUNCT=1 ;; - esac - fi -]) -m4trace:gnulib-m4/iswxdigit.m4:7: -1- AC_DEFUN([gl_FUNC_ISWXDIGIT], [ - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) - AC_REQUIRE([gl_WCTYPE_H]) - AC_REQUIRE([gt_LOCALE_JA]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([gt_LOCALE_ZH_CN]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then - dnl redefines iswxdigit already. - REPLACE_ISWXDIGIT="$REPLACE_ISWCNTRL" - else - AC_CACHE_CHECK([whether iswxdigit is ISO C compliant], - [gl_cv_func_iswxdigit_works], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on FreeBSD, NetBSD, Solaris, native Windows. - freebsd* | dragonfly* | netbsd* | solaris* | mingw* | windows*) - gl_cv_func_iswxdigit_works="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_iswxdigit_works="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_JA != none || test $LOCALE_FR_UTF8 != none || test $LOCALE_ZH_CN != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include -#include - -/* Returns the value of iswxdigit for the multibyte character s[0..n-1]. */ -static int -for_character (const char *s, size_t n) -{ - mbstate_t state; - wchar_t wc; - size_t ret; - - memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; - ret = mbrtowc (&wc, s, n, &state); - if (ret != n) - abort (); - - return iswxdigit (wc); -} - -int -main (int argc, char *argv[]) -{ - int is; - int result = 0; - - if (strcmp ("$LOCALE_JA", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_JA") != NULL) - { - /* This fails on NetBSD 8.0. */ - /* U+FF21 FULLWIDTH LATIN CAPITAL LETTER A */ - is = for_character ("\243\301", 2); - if (!(is == 0)) - result |= 1; - } - if (strcmp ("$LOCALE_FR_UTF8", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - /* This fails on FreeBSD 13.0. */ - /* U+0663 ARABIC-INDIC DIGIT THREE */ - is = for_character ("\331\243", 2); - if (!(is == 0)) - result |= 2; - /* This fails on MSVC 14. */ - /* U+FF21 FULLWIDTH LATIN CAPITAL LETTER A */ - is = for_character ("\357\274\241", 3); - if (!(is == 0)) - result |= 4; - } - if (strcmp ("$LOCALE_ZH_CN", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL) - { - /* This fails on Solaris 10, Solaris 11.4. */ - /* U+FF11 FULLWIDTH DIGIT ONE */ - is = for_character ("\243\261", 2); - if (!(is == 0)) - result |= 8; - } - return result; -}]])], - [gl_cv_func_iswxdigit_works=yes], - [gl_cv_func_iswxdigit_works=no], - [:]) - fi - ]) - case "$gl_cv_func_iswxdigit_works" in - *yes) ;; - *) REPLACE_ISWXDIGIT=1 ;; - esac - fi -]) -m4trace:gnulib-m4/java.m4:8: -1- AC_DEFUN([gt_JAVA_CHOICE], [ - AC_MSG_CHECKING([whether to use Java]) - AC_ARG_ENABLE(java, - [ --disable-java do not build Java sources], - [JAVA_CHOICE="$enableval"], - [JAVA_CHOICE=yes]) - AC_MSG_RESULT([$JAVA_CHOICE]) - AC_SUBST([JAVA_CHOICE]) -]) -m4trace:gnulib-m4/javacomp.m4:73: -1- AC_DEFUN([gt_JAVACOMP], [ - m4_if([$2], [], [AC_REQUIRE([gt_JAVAEXEC])], []) - AC_EGREP_CPP([yes], [ -#if defined _WIN32 || defined __CYGWIN__ || defined __EMX__ || defined __DJGPP__ - yes -#endif -], CLASSPATH_SEPARATOR=';', CLASSPATH_SEPARATOR=':') - source_version=$1 - test -n "$source_version" || { - AC_MSG_ERROR([missing source-version argument to gt_@&t@JAVACOMP]) - } - case "$source_version" in - 1.1 | 1.2 | 1.3 | 1.4 | 1.5) source_version='1.6' ;; - esac - m4_if([$2], [], - [if test -n "$HAVE_JAVAEXEC"; then - dnl Use $CONF_JAVA to determine the JVM's version. -changequote(,)dnl - cat > conftestver.java <"!=fYpYJmkb_ece_YnejiJpblmeji/!?!@)!A/!B!C"!._jicnbmnpbl"!3fYpYKgYidKSZfb_n"!3fYpYKgYidKUqmnbh"!$jon"!8QfYpYKejKTleinUnlbYhL"!.dbnTljkblnq"!EFQfYpYKgYidKUnleidLGQfYpYKgYidKUnleidL"!6fYpYKejKTleinUnlbYh"!)kleingi"!8FQfYpYKgYidKUnleidLGW!D!(!)!!!!!#!"!*!+!"!,!!!@!"!"!!!&Hu!"r!!!"!.!!!(!"!!!"!+!/!0!"!,!!!F!#!"!!!/s!#5$v!%t!&r!!!"!.!!!,!#!!!$!.!%!"!1!!!#!2' \ - | tr -d '\012\015' \ - | tr '!"#$%&()*+,./0123456789:;<=>?@ABCDEFGHJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyzI' '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\040\041\046\050\051\052\056\057\073\074\076\103\106\114\116\117\120\123\124\126\133\141\142\143\144\145\146\147\151\152\154\155\156\157\160\162\163\164\165\166\171\261\262\266\267\270\272\276\312\376\055' \ - > conftestver.class - java_exec_version=`{ - unset JAVA_HOME - echo "$as_me:__oline__: CLASSPATH=.${CLASSPATH:+$CLASSPATH_SEPARATOR$CLASSPATH} $CONF_JAVA conftestver" >&AS_MESSAGE_LOG_FD - CLASSPATH=.${CLASSPATH:+$CLASSPATH_SEPARATOR$CLASSPATH} $CONF_JAVA conftestver 2>&AS_MESSAGE_LOG_FD - }` - case "$java_exec_version" in - null) - dnl JDK 1.1.X returns null. - java_exec_version=1.1 ;; - esac - case "$java_exec_version" in - 1.1 | 1.2 | 1.3 | 1.4 | 1.5) - AC_MSG_WARN([$CONF_JAVA is too old, cannot compile Java code for this old version any more]) - target_version=1.6 ;; -changequote(,)dnl - 1.6 | 1.7 | 1.8 | 9 | [1-9][0-9]) -changequote([,])dnl - dnl Here we could choose any target_version between $source_version - dnl and the $java_exec_version. (If it is too small, it will be - dnl incremented below until it works.) Since we documented above that - dnl it is determined from the JVM, we do that: - target_version="$java_exec_version" ;; - *) AC_MSG_WARN([unknown target-version $target_version, please update gt_@&t@JAVACOMP macro]) - target_version=1.6 ;; - esac - else - target_version="1.6" - fi - ], - [target_version=$2 - case "$target_version" in - 1.1 | 1.2 | 1.3 | 1.4 | 1.5) target_version='1.6' ;; - esac - ]) - case "$source_version" in -changequote(,)dnl - 1.6 | 1.7 | 1.8 | 9 | [1-9][0-9]) ;; -changequote([,])dnl - *) AC_MSG_ERROR([invalid source-version argument to gt_@&t@JAVACOMP: $source_version]) ;; - esac - case "$target_version" in -changequote(,)dnl - 1.6 | 1.7 | 1.8 | 9 | [1-9][0-9]) ;; -changequote([,])dnl - *) AC_MSG_ERROR([invalid target-version argument to gt_@&t@JAVACOMP: $target_version]) ;; - esac - # Function to output the classfile version of a file (8th byte) in decimal. - if od -A x < /dev/null >/dev/null 2>/dev/null; then - # Use POSIX od. - func_classfile_version () - { - od -A n -t d1 -j 7 -N 1 "[$]1" - } - else - # Use BSD hexdump. - func_classfile_version () - { - dd if="[$]1" bs=1 count=1 skip=7 2>/dev/null | hexdump -e '1/1 "%3d "' - echo - } - fi - AC_MSG_CHECKING([for Java compiler]) - dnl - dnl The support of Sun/Oracle javac for target-version and source-version: - dnl - dnl javac 1.6: -target 1.1 1.2 1.3 1.4 1.5 1.6 default: 1.6 - dnl -source 1.3 1.4 1.5 1.6 default: 1.5 - dnl -target 1.1/1.2/1.3 only possible with -source 1.3 - dnl -target 1.4 only possible with -source 1.3/1.4 - dnl -target 1.5 only possible with -source 1.3/1.4/1.5 or no -source - dnl - dnl javac 1.7: -target 1.1 1.2 1.3 1.4 1.5 1.6 1.7 default: 1.7 - dnl -source 1.3 1.4 1.5 1.6 1.7 default: 1.7 - dnl -target 1.1/1.2/1.3 only possible with -source 1.3 - dnl -target 1.4 only possible with -source 1.3/1.4 - dnl -target 1.5 only possible with -source 1.3/1.4/1.5 - dnl -target 1.6 only possible with -source 1.3/1.4/1.5/1.6 - dnl - dnl javac 1.8: -target 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 default: 1.8 - dnl -source 1.3 1.4 1.5 1.6 1.7 1.8 default: 1.8 - dnl -target 1.1/1.2/1.3 only possible with -source 1.3 - dnl -target 1.4 only possible with -source 1.3/1.4 - dnl -target 1.5 only possible with -source 1.3/1.4/1.5 - dnl -target 1.6 only possible with -source 1.3/1.4/1.5/1.6 - dnl -target 1.7 only possible with -source 1.3/1.4/1.5/1.6/1.7 - dnl - dnl javac 9: -target 1.6 1.7 1.8 9 default: 9 - dnl -source 1.6 1.7 1.8 9 default: 9 - dnl -target 1.6 only possible with -source 1.6 - dnl -target 1.7 only possible with -source 1.6/1.7 - dnl -target 1.8 only possible with -source 1.6/1.7/1.8 - dnl - dnl javac 10: -target 1.6 1.7 1.8 9 10 default: 10 - dnl -source 1.6 1.7 1.8 9 10 default: 10 - dnl -target 1.6 only possible with -source 1.6 - dnl -target 1.7 only possible with -source 1.6/1.7 - dnl -target 1.8 only possible with -source 1.6/1.7/1.8 - dnl -target 9 only possible with -source 1.6/1.7/1.8/9 - dnl - dnl and so on. - dnl This can be summarized in this table: - dnl - dnl javac classfile valid -source and obsolete -source - dnl version default version -target values and -target values - dnl ------- --------------- ----------------- ------------------ - dnl 1.6 50.0 1.2 .. 1.6 - dnl 1.7 51.0 1.2 .. 1.7 - dnl 1.8 52.0 1.3 .. 1.8 1.3 .. 1.5 - dnl 9 53.0 1.6 .. 9 1.6 - dnl 10 54.0 1.6 .. 10 1.6 - dnl 11 55.0 1.6 .. 11 1.6 - dnl 12 56.0 1.7 .. 12 1.7 - dnl 13 57.0 1.7 .. 13 1.7 - dnl 14 58.0 1.7 .. 14 1.7 - dnl 15 59.0 1.7 .. 15 1.7 - dnl 16 60.0 1.7 .. 16 1.7 - dnl 17 61.0 1.7 .. 17 1.7 - dnl 18 62.0 1.7 .. 18 1.7 - dnl 19 63.0 1.7 .. 19 1.7 - dnl 20 64.0 1.8 .. 20 1.8 - dnl - dnl The -source option value must be <= the -target option value. - dnl The minimal -source and -target option value produces an "is obsolete" - dnl warning (in javac 1.8 or newer). Additionally, if the -source option - dnl value is not the maximal possible one, i.e. not redundant, it produces a - dnl "bootstrap class path not set in conjunction with -source ..." warning - dnl (in javac 1.7 or newer). - dnl - dnl To get rid of these warnings, two options are available: - dnl * -nowarn. This option is supported since javac 1.6 at least. But - dnl it is overkill, because it would also silence warnings about the - dnl code being compiled. - dnl * -Xlint:-options. This option is supported since javac 1.6 at least. - dnl In javac 1.6 it is an undocumented no-op. - dnl We use -Xlint:-options and omit it only if we find that the compiler - dnl does not support it (which is unlikely). - dnl - dnl Canonicalize source_version and target_version, for easier arithmetic. - case "$source_version" in - 1.*) source_version=`echo "$source_version" | sed -e 's/^1\.//'` ;; - esac - case "$target_version" in - 1.*) target_version=`echo "$target_version" | sed -e 's/^1\.//'` ;; - esac - CONF_JAVAC= - HAVE_JAVAC_ENVVAR= - HAVE_JAVAC= - HAVE_JAVACOMP= - dnl Sanity check. - if expr $source_version '<=' $target_version >/dev/null; then - echo 'class conftest {}' > conftest.java - dnl If the user has set the JAVAC environment variable, use that, if it - dnl satisfies the constraints (possibly after adding -target and -source - dnl options). - if test -n "$JAVAC"; then - dnl Test whether $JAVAC is usable. - dnl At the same time, determine which option to use to inhibit warnings; - dnl see the discussion above. - nowarn_option=' -Xlint:-options' - if { rm -f conftest.class \ - && { echo "$as_me:__oline__: $JAVAC$nowarn_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - $JAVAC$nowarn_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class - } || { \ - nowarn_option= - rm -f conftest.class \ - && { echo "$as_me:__oline__: $JAVAC$nowarn_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - $JAVAC$nowarn_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class - }; then - compiler_cfversion=`func_classfile_version conftest.class` - compiler_target_version=`expr $compiler_cfversion - 44` - dnl It is hard to determine the compiler_source_version. This would - dnl require a list of code snippets that can be compiled only with a - dnl specific '-source' option and up, and this list would need to grow - dnl every 6 months. - dnl Also, $JAVAC may already include a '-source' option. - dnl Therefore, pass a '-source' option always. - source_option=' -source '`case "$source_version" in 6|7|8) echo 1. ;; esac`"$source_version" - dnl And pass a '-target' option as well, if needed. - dnl (All supported javac versions support both, see the table above.) - if expr $target_version = $compiler_target_version >/dev/null; then - target_option= - else - target_option=' -target '`case "$target_version" in 6|7|8) echo 1. ;; esac`"$target_version" - fi - if { echo "$as_me:__oline__: $JAVAC$nowarn_option$source_option$target_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - $JAVAC$nowarn_option$source_option$target_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class; then - dnl The compiler directly supports the desired source_version and - dnl target_version. Perfect. - CONF_JAVAC="$JAVAC$nowarn_option$source_option$target_option" - HAVE_JAVAC_ENVVAR=1 - HAVE_JAVACOMP=1 - else - dnl If the desired source_version or target_version were too large - dnl for the compiler, there's nothing else we can do. - compiler_version=`echo "$as_me:__oline__: $JAVAC -version | sed -e 1q" >&AS_MESSAGE_LOG_FD - $JAVAC -version | sed -e 1q` -changequote(,)dnl - compiler_version=`echo "$compiler_version" | sed -e 's/^[^0-9]*\([0-9][0-9.]*\).*/\1/'` -changequote([,])dnl - case "$compiler_version" in - 1.*) dnl Map 1.6.0_85 to 6, 1.8.0_151 to 8. - compiler_version=`echo "$compiler_version" | sed -e 's/^1\.//' -e 's/\..*//'` - ;; - *) dnl Map 9.0.4 to 9, 10.0.2 to 10, etc. - compiler_version=`echo "$compiler_version" | sed -e 's/\..*//'` - ;; - esac - if expr $source_version '<=' "$compiler_version" >/dev/null \ - && expr $target_version '<=' "$compiler_version" >/dev/null; then - dnl Increase $source_version and $compiler_version until the - dnl compiler accepts these values. This is necessary to make - dnl e.g. $source_version = 6 work with Java 12 or newer, or - dnl $source_version = 7 work with Java 20 or newer. - try_source_version="$source_version" - try_target_version="$target_version" - while true; do - dnl Invariant: $try_source_version <= $try_target_version. - if expr $try_source_version = $try_target_version >/dev/null; then - try_target_version=`expr $try_target_version + 1` - fi - try_source_version=`expr $try_source_version + 1` - expr $try_source_version '<=' $compiler_version >/dev/null || break - source_option=' -source '`case "$try_source_version" in 6|7|8) echo 1. ;; esac`"$try_source_version" - if expr $try_target_version = $compiler_target_version >/dev/null; then - target_option= - else - target_option=' -target '`case "$try_target_version" in 6|7|8) echo 1. ;; esac`"$try_target_version" - fi - if { echo "$as_me:__oline__: $JAVAC$nowarn_option$source_option$target_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - $JAVAC$nowarn_option$source_option$target_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class; then - dnl The compiler supports the try_source_version and - dnl try_target_version. It's better than nothing. - CONF_JAVAC="$JAVAC$nowarn_option$source_option$target_option" - HAVE_JAVAC_ENVVAR=1 - HAVE_JAVACOMP=1 - break - fi - done - fi - fi - fi - fi - if test -z "$HAVE_JAVACOMP"; then - pushdef([AC_MSG_CHECKING],[:])dnl - pushdef([AC_CHECKING],[:])dnl - pushdef([AC_MSG_RESULT],[:])dnl - AC_CHECK_PROG([HAVE_JAVAC_IN_PATH], [javac], [yes]) - popdef([AC_MSG_RESULT])dnl - popdef([AC_CHECKING])dnl - popdef([AC_MSG_CHECKING])dnl - if test -z "$HAVE_JAVACOMP" && test -n "$HAVE_JAVAC_IN_PATH"; then - dnl Test whether javac is usable. - dnl At the same time, determine which option to use to inhibit warnings; - dnl see the discussion above. - nowarn_option=' -Xlint:-options' - if { rm -f conftest.class \ - && { echo "$as_me:__oline__: javac$nowarn_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - javac$nowarn_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class - } || { \ - nowarn_option= - rm -f conftest.class \ - && { echo "$as_me:__oline__: javac$nowarn_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - javac$nowarn_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class - }; then - compiler_cfversion=`func_classfile_version conftest.class` - compiler_target_version=`expr $compiler_cfversion - 44` - dnl It is hard to determine the compiler_source_version. This would - dnl require a list of code snippets that can be compiled only with a - dnl specific '-source' option and up, and this list would need to grow - dnl every 6 months. - dnl Also, javac may point to a shell script that already includes a - dnl '-source' option. - dnl Therefore, pass a '-source' option always. - source_option=' -source '`case "$source_version" in 6|7|8) echo 1. ;; esac`"$source_version" - dnl And pass a '-target' option as well, if needed. - dnl (All supported javac versions support both, see the table above.) - if expr $target_version = $compiler_target_version >/dev/null; then - target_option= - else - target_option=' -target '`case "$target_version" in 6|7|8) echo 1. ;; esac`"$target_version" - fi - if { echo "$as_me:__oline__: javac$nowarn_option$source_option$target_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - javac$nowarn_option$source_option$target_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class; then - dnl The compiler directly supports the desired source_version and - dnl target_version. Perfect. - CONF_JAVAC="javac$nowarn_option$source_option$target_option" - HAVE_JAVAC=1 - HAVE_JAVACOMP=1 - else - dnl If the desired source_version or target_version were too large - dnl for the compiler, there's nothing else we can do. - compiler_version=`echo "$as_me:__oline__: javac -version | sed -e 1q" >&AS_MESSAGE_LOG_FD - javac -version | sed -e 1q` -changequote(,)dnl - compiler_version=`echo "$compiler_version" | sed -e 's/^[^0-9]*\([0-9][0-9.]*\).*/\1/'` -changequote([,])dnl - case "$compiler_version" in - 1.*) dnl Map 1.6.0_85 to 6, 1.8.0_151 to 8. - compiler_version=`echo "$compiler_version" | sed -e 's/^1\.//' -e 's/\..*//'` - ;; - *) dnl Map 9.0.4 to 9, 10.0.2 to 10, etc. - compiler_version=`echo "$compiler_version" | sed -e 's/\..*//'` - ;; - esac - if expr $source_version '<=' "$compiler_version" >/dev/null \ - && expr $target_version '<=' "$compiler_version" >/dev/null; then - dnl Increase $source_version and $compiler_version until the - dnl compiler accepts these values. This is necessary to make - dnl e.g. $source_version = 6 work with Java 12 or newer, or - dnl $source_version = 7 work with Java 20 or newer. - try_source_version="$source_version" - try_target_version="$target_version" - while true; do - dnl Invariant: $try_source_version <= $try_target_version. - if expr $try_source_version = $try_target_version >/dev/null; then - try_target_version=`expr $try_target_version + 1` - fi - try_source_version=`expr $try_source_version + 1` - expr $try_source_version '<=' $compiler_version >/dev/null || break - source_option=' -source '`case "$try_source_version" in 6|7|8) echo 1. ;; esac`"$try_source_version" - if expr $try_target_version = $compiler_target_version >/dev/null; then - target_option= - else - target_option=' -target '`case "$try_target_version" in 6|7|8) echo 1. ;; esac`"$try_target_version" - fi - if { echo "$as_me:__oline__: javac$nowarn_option$source_option$target_option -d . conftest.java" >&AS_MESSAGE_LOG_FD - javac$nowarn_option$source_option$target_option -d . conftest.java >&AS_MESSAGE_LOG_FD 2>&1 - } \ - && test -f conftest.class; then - dnl The compiler supports the try_source_version and - dnl try_target_version. It's better than nothing. - CONF_JAVAC="javac$nowarn_option$source_option$target_option" - HAVE_JAVAC=1 - HAVE_JAVACOMP=1 - break - fi - done - fi - fi - fi - fi - fi - rm -f conftest*.java conftest*.class - fi - if test -n "$HAVE_JAVACOMP"; then - ac_result="$CONF_JAVAC" - else - ac_result="no" - fi - AC_MSG_RESULT([$ac_result]) - AC_SUBST([CONF_JAVAC]) - AC_SUBST([CLASSPATH]) - AC_SUBST([CLASSPATH_SEPARATOR]) - AC_SUBST([HAVE_JAVAC_ENVVAR]) - AC_SUBST([HAVE_JAVAC]) -]) -m4trace:gnulib-m4/javacomp.m4:485: -1- AC_DEFUN([gt_JAVACOMP_DISABLED], [ - CONF_JAVAC= - HAVE_JAVAC_ENVVAR= - HAVE_JAVAC= - AC_SUBST([CONF_JAVAC]) - AC_SUBST([HAVE_JAVAC_ENVVAR]) - AC_SUBST([HAVE_JAVAC]) -]) -m4trace:gnulib-m4/langinfo_h.m4:7: -1- AC_DEFUN_ONCE([gl_LANGINFO_H], [ - AC_REQUIRE([gl_LANGINFO_H_DEFAULTS]) - - dnl Persuade glibc-2.0.6 to define CODESET. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - dnl is always overridden, because of GNULIB_POSIXCHECK. - gl_CHECK_NEXT_HEADERS([langinfo.h]) - - dnl Determine whether exists. It is missing on mingw and BeOS. - HAVE_LANGINFO_CODESET=0 - HAVE_LANGINFO_T_FMT_AMPM=0 - HAVE_LANGINFO_ALTMON=0 - HAVE_LANGINFO_ERA=0 - HAVE_LANGINFO_YESEXPR=0 - AC_CHECK_HEADERS_ONCE([langinfo.h]) - if test $ac_cv_header_langinfo_h = yes; then - HAVE_LANGINFO_H=1 - dnl Determine what defines. - dnl CODESET is missing on OpenBSD 3.8. - dnl ERA etc. are missing on OpenBSD 6.7. - dnl T_FMT_AMPM and YESEXPR, NOEXPR are missing on IRIX 5.3. - dnl ALTMON_* are missing on glibc 2.26 and many other systems. - AC_CACHE_CHECK([whether langinfo.h defines CODESET], - [gl_cv_header_langinfo_codeset], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include -int a = CODESET; -]])], - [gl_cv_header_langinfo_codeset=yes], - [gl_cv_header_langinfo_codeset=no]) - ]) - if test $gl_cv_header_langinfo_codeset = yes; then - HAVE_LANGINFO_CODESET=1 - fi - AC_CACHE_CHECK([whether langinfo.h defines T_FMT_AMPM], - [gl_cv_header_langinfo_t_fmt_ampm], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include -int a = T_FMT_AMPM; -]])], - [gl_cv_header_langinfo_t_fmt_ampm=yes], - [gl_cv_header_langinfo_t_fmt_ampm=no]) - ]) - if test $gl_cv_header_langinfo_t_fmt_ampm = yes; then - HAVE_LANGINFO_T_FMT_AMPM=1 - fi - AC_CACHE_CHECK([whether langinfo.h defines ALTMON_1], - [gl_cv_header_langinfo_altmon], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include -int a = ALTMON_1; -]])], - [gl_cv_header_langinfo_altmon=yes], - [gl_cv_header_langinfo_altmon=no]) - ]) - if test $gl_cv_header_langinfo_altmon = yes; then - HAVE_LANGINFO_ALTMON=1 - fi - AC_CACHE_CHECK([whether langinfo.h defines ERA], - [gl_cv_header_langinfo_era], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include -int a = ERA; -]])], - [gl_cv_header_langinfo_era=yes], - [gl_cv_header_langinfo_era=no]) - ]) - if test $gl_cv_header_langinfo_era = yes; then - HAVE_LANGINFO_ERA=1 - fi - AC_CACHE_CHECK([whether langinfo.h defines YESEXPR], - [gl_cv_header_langinfo_yesexpr], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include -int a = YESEXPR; -]])], - [gl_cv_header_langinfo_yesexpr=yes], - [gl_cv_header_langinfo_yesexpr=no]) - ]) - if test $gl_cv_header_langinfo_yesexpr = yes; then - HAVE_LANGINFO_YESEXPR=1 - fi - else - HAVE_LANGINFO_H=0 - fi - AC_SUBST([HAVE_LANGINFO_H]) - AC_SUBST([HAVE_LANGINFO_CODESET]) - AC_SUBST([HAVE_LANGINFO_T_FMT_AMPM]) - AC_SUBST([HAVE_LANGINFO_ALTMON]) - AC_SUBST([HAVE_LANGINFO_ERA]) - AC_SUBST([HAVE_LANGINFO_YESEXPR]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[#include - ]], [nl_langinfo]) -]) -m4trace:gnulib-m4/langinfo_h.m4:111: -1- AC_DEFUN([gl_LANGINFO_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_LANGINFO_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/langinfo_h.m4:123: -1- AC_DEFUN([gl_LANGINFO_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_LANGINFO_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NL_LANGINFO]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_LANGINFO_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_LANGINFO_H_DEFAULTS]) -]) -m4trace:gnulib-m4/langinfo_h.m4:132: -1- AC_DEFUN([gl_LANGINFO_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_NL_LANGINFO=1; AC_SUBST([HAVE_NL_LANGINFO]) - REPLACE_NL_LANGINFO=0; AC_SUBST([REPLACE_NL_LANGINFO]) -]) -m4trace:gnulib-m4/largefile.m4:14: -1- AC_DEFUN([gl_SET_LARGEFILE_SOURCE], [ -]) -m4trace:gnulib-m4/largefile.m4:304: -1- AC_DEFUN([gl_LARGEFILE], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - mingw* | windows*) - dnl Native Windows. - dnl mingw64 defines off_t to a 64-bit type already, if - dnl _FILE_OFFSET_BITS=64, which is ensured by AC_SYS_LARGEFILE. - AC_CACHE_CHECK([for 64-bit off_t], [gl_cv_type_off_t_64], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - int verify_off_t_size[sizeof (off_t) >= 8 ? 1 : -1]; - ]], - [[]])], - [gl_cv_type_off_t_64=yes], [gl_cv_type_off_t_64=no]) - ]) - if test $gl_cv_type_off_t_64 = no; then - WINDOWS_64_BIT_OFF_T=1 - else - WINDOWS_64_BIT_OFF_T=0 - fi - dnl Some mingw versions define, if _FILE_OFFSET_BITS=64, 'struct stat' - dnl to 'struct _stat32i64' or 'struct _stat64' (depending on - dnl _USE_32BIT_TIME_T), which has a 32-bit st_size member. - AC_CACHE_CHECK([for 64-bit st_size], [gl_cv_member_st_size_64], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - struct stat buf; - int verify_st_size_size[sizeof (buf.st_size) >= 8 ? 1 : -1]; - ]], - [[]])], - [gl_cv_member_st_size_64=yes], [gl_cv_member_st_size_64=no]) - ]) - if test $gl_cv_member_st_size_64 = no; then - WINDOWS_64_BIT_ST_SIZE=1 - else - WINDOWS_64_BIT_ST_SIZE=0 - fi - ;; - *) - dnl Nothing to do on gnulib's side. - dnl A 64-bit off_t is - dnl - already the default on Mac OS X, FreeBSD, NetBSD, OpenBSD, IRIX, - dnl OSF/1, Cygwin, - dnl - enabled by _FILE_OFFSET_BITS=64 (ensured by AC_SYS_LARGEFILE) on - dnl glibc, HP-UX, Solaris, - dnl - enabled by _LARGE_FILES=1 (ensured by AC_SYS_LARGEFILE) on AIX, - dnl - impossible to achieve on Minix 3.1.8. - WINDOWS_64_BIT_OFF_T=0 - WINDOWS_64_BIT_ST_SIZE=0 - ;; - esac -]) -m4trace:gnulib-m4/lcmessage.m4:22: -1- AC_DEFUN([gt_LC_MESSAGES], [ - AC_CACHE_CHECK([for LC_MESSAGES], [gt_cv_val_LC_MESSAGES], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[return LC_MESSAGES]])], - [gt_cv_val_LC_MESSAGES=yes], - [gt_cv_val_LC_MESSAGES=no])]) - if test $gt_cv_val_LC_MESSAGES = yes; then - AC_DEFINE([HAVE_LC_MESSAGES], [1], - [Define if your file defines LC_MESSAGES.]) - fi -]) -m4trace:gnulib-m4/lib-ld.m4:12: -1- AC_DEFUN([AC_LIB_PROG_LD_GNU], [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld], -[# I'd rather use --version here, but apparently some GNU lds only accept -v. -case `$LD -v 2>&1 /dev/null 2>&1 \ - && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ - || PATH_SEPARATOR=';' - } -fi - -if test -n "$LD"; then - AC_MSG_CHECKING([for ld]) -elif test "$GCC" = yes; then - AC_MSG_CHECKING([for ld used by $CC]) -elif test "$with_gnu_ld" = yes; then - AC_MSG_CHECKING([for GNU ld]) -else - AC_MSG_CHECKING([for non-GNU ld]) -fi -if test -n "$LD"; then - # Let the user override the test with a path. - : -else - AC_CACHE_VAL([acl_cv_path_LD], - [ - acl_cv_path_LD= # Final result of this test - ac_prog=ld # Program to search in $PATH - if test "$GCC" = yes; then - # Check if gcc -print-prog-name=ld gives a path. - case $host in - *-*-mingw* | windows*) - # gcc leaves a trailing carriage return which upsets mingw - acl_output=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; - *) - acl_output=`($CC -print-prog-name=ld) 2>&5` ;; - esac - case $acl_output in - # Accept absolute paths. - [[\\/]]* | ?:[[\\/]]*) - re_direlt='/[[^/]][[^/]]*/\.\./' - # Canonicalize the pathname of ld - acl_output=`echo "$acl_output" | sed 's%\\\\%/%g'` - while echo "$acl_output" | grep "$re_direlt" > /dev/null 2>&1; do - acl_output=`echo $acl_output | sed "s%$re_direlt%/%"` - done - # Got the pathname. No search in PATH is needed. - acl_cv_path_LD="$acl_output" - ac_prog= - ;; - "") - # If it fails, then pretend we aren't using GCC. - ;; - *) - # If it is relative, then search for the first ld in PATH. - with_gnu_ld=unknown - ;; - esac - fi - if test -n "$ac_prog"; then - # Search for $ac_prog in $PATH. - acl_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR - for ac_dir in $PATH; do - IFS="$acl_saved_IFS" - test -z "$ac_dir" && ac_dir=. - if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then - acl_cv_path_LD="$ac_dir/$ac_prog" - # Check to see if the program is GNU ld. I'd rather use --version, - # but apparently some variants of GNU ld only accept -v. - # Break only if it was the GNU/non-GNU ld that we prefer. - case `"$acl_cv_path_LD" -v 2>&1 conftest.sh - . ./conftest.sh - rm -f ./conftest.sh - acl_cv_rpath=done - ]) - wl="$acl_cv_wl" - acl_libext="$acl_cv_libext" - acl_shlibext="$acl_cv_shlibext" - acl_libname_spec="$acl_cv_libname_spec" - acl_library_names_spec="$acl_cv_library_names_spec" - acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" - acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" - acl_hardcode_direct="$acl_cv_hardcode_direct" - acl_hardcode_minus_L="$acl_cv_hardcode_minus_L" - dnl Determine whether the user wants rpath handling at all. - AC_ARG_ENABLE([rpath], - [ --disable-rpath do not hardcode runtime library paths], - :, enable_rpath=yes) -]) -m4trace:gnulib-m4/lib-link.m4:161: -1- AC_DEFUN([AC_LIB_FROMPACKAGE], [ - pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) - define([acl_frompackage_]NAME, [$2]) - popdef([NAME]) - pushdef([PACK],[$2]) - pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) - define([acl_libsinpackage_]PACKUP, - m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[, ]],)[lib$1]) - popdef([PACKUP]) - popdef([PACK]) -]) -m4trace:gnulib-m4/lib-link.m4:181: -1- AC_DEFUN([AC_LIB_LINKFLAGS_BODY], [ - AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) - pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) - pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])]) - pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) - pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])]) - dnl By default, look in $includedir and $libdir. - use_additional=yes - AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) - AC_ARG_WITH(PACK[-prefix], -[[ --with-]]PACK[[-prefix[=DIR] search for ]]PACKLIBS[[ in DIR/include and DIR/lib - --without-]]PACK[[-prefix don't search for ]]PACKLIBS[[ in includedir and libdir]], -[ - if test "X$withval" = "Xno"; then - use_additional=no - else - if test "X$withval" = "X"; then - AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) - else - additional_includedir="$withval/include" - additional_libdir="$withval/$acl_libdirstem" - additional_libdir2="$withval/$acl_libdirstem2" - additional_libdir3="$withval/$acl_libdirstem3" - fi - fi -]) - if test "X$additional_libdir2" = "X$additional_libdir"; then - additional_libdir2= - fi - if test "X$additional_libdir3" = "X$additional_libdir"; then - additional_libdir3= - fi - dnl Search the library and its dependencies in $additional_libdir and - dnl $LDFLAGS. Use breadth-first search. - LIB[]NAME= - LTLIB[]NAME= - INC[]NAME= - LIB[]NAME[]_PREFIX= - dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been - dnl computed. So it has to be reset here. - HAVE_LIB[]NAME= - rpathdirs= - ltrpathdirs= - names_already_handled= - names_next_round='$1 $2' - while test -n "$names_next_round"; do - names_this_round="$names_next_round" - names_next_round= - for name in $names_this_round; do - already_handled= - for n in $names_already_handled; do - if test "$n" = "$name"; then - already_handled=yes - break - fi - done - if test -z "$already_handled"; then - names_already_handled="$names_already_handled $name" - dnl See if it was already located by an earlier AC_LIB_LINKFLAGS - dnl or AC_LIB_HAVE_LINKFLAGS call. - uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'` - eval value=\"\$HAVE_LIB$uppername\" - if test -n "$value"; then - if test "$value" = yes; then - eval value=\"\$LIB$uppername\" - test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" - eval value=\"\$LTLIB$uppername\" - test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" - else - dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined - dnl that this library doesn't exist. So just drop it. - : - fi - else - dnl Search the library lib$name in $additional_libdir and $LDFLAGS - dnl and the already constructed $LIBNAME/$LTLIBNAME. - found_dir= - found_la= - found_so= - found_a= - eval libname=\"$acl_libname_spec\" # typically: libname=lib$name - if test -n "$acl_shlibext"; then - shrext=".$acl_shlibext" # typically: shrext=.so - else - shrext= - fi - if test $use_additional = yes; then - for additional_libdir_variable in additional_libdir additional_libdir2 additional_libdir3; do - if test "X$found_dir" = "X"; then - eval dir=\$$additional_libdir_variable - if test -n "$dir"; then - dnl The same code as in the loop below: - dnl First look for a shared library. - if test -n "$acl_shlibext"; then - if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then - found_dir="$dir" - found_so="$dir/$libname$shrext" - else - if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then - ver=`(cd "$dir" && \ - for f in "$libname$shrext".*; do echo "$f"; done \ - | sed -e "s,^$libname$shrext\\\\.,," \ - | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ - | sed 1q ) 2>/dev/null` - if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then - found_dir="$dir" - found_so="$dir/$libname$shrext.$ver" - fi - else - eval library_names=\"$acl_library_names_spec\" - for f in $library_names; do - if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then - found_dir="$dir" - found_so="$dir/$f" - break - fi - done - fi - fi - fi - dnl Then look for a static library. - if test "X$found_dir" = "X"; then - if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then - found_dir="$dir" - found_a="$dir/$libname.$acl_libext" - fi - fi - if test "X$found_dir" != "X"; then - if test -f "$dir/$libname.la"; then - found_la="$dir/$libname.la" - fi - fi - fi - fi - done - fi - if test "X$found_dir" = "X"; then - for x in $LDFLAGS $LTLIB[]NAME; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - case "$x" in - -L*) - dir=`echo "X$x" | sed -e 's/^X-L//'` - dnl First look for a shared library. - if test -n "$acl_shlibext"; then - if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then - found_dir="$dir" - found_so="$dir/$libname$shrext" - else - if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then - ver=`(cd "$dir" && \ - for f in "$libname$shrext".*; do echo "$f"; done \ - | sed -e "s,^$libname$shrext\\\\.,," \ - | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ - | sed 1q ) 2>/dev/null` - if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then - found_dir="$dir" - found_so="$dir/$libname$shrext.$ver" - fi - else - eval library_names=\"$acl_library_names_spec\" - for f in $library_names; do - if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then - found_dir="$dir" - found_so="$dir/$f" - break - fi - done - fi - fi - fi - dnl Then look for a static library. - if test "X$found_dir" = "X"; then - if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then - found_dir="$dir" - found_a="$dir/$libname.$acl_libext" - fi - fi - if test "X$found_dir" != "X"; then - if test -f "$dir/$libname.la"; then - found_la="$dir/$libname.la" - fi - fi - ;; - esac - if test "X$found_dir" != "X"; then - break - fi - done - fi - if test "X$found_dir" != "X"; then - dnl Found the library. - LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" - if test "X$found_so" != "X"; then - dnl Linking with a shared library. We attempt to hardcode its - dnl directory into the executable's runpath, unless it's the - dnl standard /usr/lib. - if test "$enable_rpath" = no \ - || test "X$found_dir" = "X/usr/$acl_libdirstem" \ - || test "X$found_dir" = "X/usr/$acl_libdirstem2" \ - || test "X$found_dir" = "X/usr/$acl_libdirstem3"; then - dnl No hardcoding is needed. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" - else - dnl Use an explicit option to hardcode DIR into the resulting - dnl binary. - dnl Potentially add DIR to ltrpathdirs. - dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. - haveit= - for x in $ltrpathdirs; do - if test "X$x" = "X$found_dir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - ltrpathdirs="$ltrpathdirs $found_dir" - fi - dnl The hardcoding into $LIBNAME is system dependent. - if test "$acl_hardcode_direct" = yes; then - dnl Using DIR/libNAME.so during linking hardcodes DIR into the - dnl resulting binary. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" - else - if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then - dnl Use an explicit option to hardcode DIR into the resulting - dnl binary. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" - dnl Potentially add DIR to rpathdirs. - dnl The rpathdirs will be appended to $LIBNAME at the end. - haveit= - for x in $rpathdirs; do - if test "X$x" = "X$found_dir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - rpathdirs="$rpathdirs $found_dir" - fi - else - dnl Rely on "-L$found_dir". - dnl But don't add it if it's already contained in the LDFLAGS - dnl or the already constructed $LIBNAME - haveit= - for x in $LDFLAGS $LIB[]NAME; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-L$found_dir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" - fi - if test "$acl_hardcode_minus_L" != no; then - dnl FIXME: Not sure whether we should use - dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" - dnl here. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" - else - dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH - dnl here, because this doesn't fit in flags passed to the - dnl compiler. So give up. No hardcoding. This affects only - dnl very old systems. - dnl FIXME: Not sure whether we should use - dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" - dnl here. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" - fi - fi - fi - fi - else - if test "X$found_a" != "X"; then - dnl Linking with a static library. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" - else - dnl We shouldn't come here, but anyway it's good to have a - dnl fallback. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" - fi - fi - dnl Assume the include files are nearby. - additional_includedir= - case "$found_dir" in - */$acl_libdirstem | */$acl_libdirstem/) - basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` - if test "$name" = '$1'; then - LIB[]NAME[]_PREFIX="$basedir" - fi - additional_includedir="$basedir/include" - ;; - */$acl_libdirstem2 | */$acl_libdirstem2/) - basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'` - if test "$name" = '$1'; then - LIB[]NAME[]_PREFIX="$basedir" - fi - additional_includedir="$basedir/include" - ;; - */$acl_libdirstem3 | */$acl_libdirstem3/) - basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem3/"'*$,,'` - if test "$name" = '$1'; then - LIB[]NAME[]_PREFIX="$basedir" - fi - additional_includedir="$basedir/include" - ;; - esac - if test "X$additional_includedir" != "X"; then - dnl Potentially add $additional_includedir to $INCNAME. - dnl But don't add it - dnl 1. if it's the standard /usr/include, - dnl 2. if it's /usr/local/include and we are using GCC on Linux, - dnl 3. if it's already present in $CPPFLAGS or the already - dnl constructed $INCNAME, - dnl 4. if it doesn't exist as a directory. - if test "X$additional_includedir" != "X/usr/include"; then - haveit= - if test "X$additional_includedir" = "X/usr/local/include"; then - if test -n "$GCC"; then - case $host_os in - linux* | gnu* | k*bsd*-gnu) haveit=yes;; - esac - fi - fi - if test -z "$haveit"; then - for x in $CPPFLAGS $INC[]NAME; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-I$additional_includedir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - if test -d "$additional_includedir"; then - dnl Really add $additional_includedir to $INCNAME. - INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" - fi - fi - fi - fi - fi - dnl Look for dependencies. - if test -n "$found_la"; then - dnl Read the .la file. It defines the variables - dnl dlname, library_names, old_library, dependency_libs, current, - dnl age, revision, installed, dlopen, dlpreopen, libdir. - saved_libdir="$libdir" - case "$found_la" in - */* | *\\*) . "$found_la" ;; - *) . "./$found_la" ;; - esac - libdir="$saved_libdir" - dnl We use only dependency_libs. - for dep in $dependency_libs; do - case "$dep" in - -L*) - dependency_libdir=`echo "X$dep" | sed -e 's/^X-L//'` - dnl Potentially add $dependency_libdir to $LIBNAME and $LTLIBNAME. - dnl But don't add it - dnl 1. if it's the standard /usr/lib, - dnl 2. if it's /usr/local/lib and we are using GCC on Linux, - dnl 3. if it's already present in $LDFLAGS or the already - dnl constructed $LIBNAME, - dnl 4. if it doesn't exist as a directory. - if test "X$dependency_libdir" != "X/usr/$acl_libdirstem" \ - && test "X$dependency_libdir" != "X/usr/$acl_libdirstem2" \ - && test "X$dependency_libdir" != "X/usr/$acl_libdirstem3"; then - haveit= - if test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem" \ - || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem2" \ - || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem3"; then - if test -n "$GCC"; then - case $host_os in - linux* | gnu* | k*bsd*-gnu) haveit=yes;; - esac - fi - fi - if test -z "$haveit"; then - haveit= - for x in $LDFLAGS $LIB[]NAME; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-L$dependency_libdir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - if test -d "$dependency_libdir"; then - dnl Really add $dependency_libdir to $LIBNAME. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$dependency_libdir" - fi - fi - haveit= - for x in $LDFLAGS $LTLIB[]NAME; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-L$dependency_libdir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - if test -d "$dependency_libdir"; then - dnl Really add $dependency_libdir to $LTLIBNAME. - LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$dependency_libdir" - fi - fi - fi - fi - ;; - -R*) - dir=`echo "X$dep" | sed -e 's/^X-R//'` - if test "$enable_rpath" != no; then - dnl Potentially add DIR to rpathdirs. - dnl The rpathdirs will be appended to $LIBNAME at the end. - haveit= - for x in $rpathdirs; do - if test "X$x" = "X$dir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - rpathdirs="$rpathdirs $dir" - fi - dnl Potentially add DIR to ltrpathdirs. - dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. - haveit= - for x in $ltrpathdirs; do - if test "X$x" = "X$dir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - ltrpathdirs="$ltrpathdirs $dir" - fi - fi - ;; - -l*) - dnl Handle this in the next round. - dnl But on GNU systems, ignore -lc options, because - dnl - linking with libc is the default anyway, - dnl - linking with libc.a may produce an error - dnl "/usr/bin/ld: dynamic STT_GNU_IFUNC symbol `strcmp' with pointer equality in `/usr/lib/libc.a(strcmp.o)' can not be used when making an executable; recompile with -fPIE and relink with -pie" - dnl or may produce an executable that always crashes, see - dnl . - dep=`echo "X$dep" | sed -e 's/^X-l//'` - if test "X$dep" != Xc \ - || case $host_os in - linux* | gnu* | k*bsd*-gnu) false ;; - *) true ;; - esac; then - names_next_round="$names_next_round $dep" - fi - ;; - *.la) - dnl Handle this in the next round. Throw away the .la's - dnl directory; it is already contained in a preceding -L - dnl option. - names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` - ;; - *) - dnl Most likely an immediate library name. - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" - LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" - ;; - esac - done - fi - else - dnl Didn't find the library; assume it is in the system directories - dnl known to the linker and runtime loader. (All the system - dnl directories known to the linker should also be known to the - dnl runtime loader, otherwise the system is severely misconfigured.) - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" - LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" - fi - fi - fi - done - done - if test "X$rpathdirs" != "X"; then - if test -n "$acl_hardcode_libdir_separator"; then - dnl Weird platform: only the last -rpath option counts, the user must - dnl pass all path elements in one option. We can arrange that for a - dnl single library, but not when more than one $LIBNAMEs are used. - alldirs= - for found_dir in $rpathdirs; do - alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir" - done - dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl. - acl_saved_libdir="$libdir" - libdir="$alldirs" - eval flag=\"$acl_hardcode_libdir_flag_spec\" - libdir="$acl_saved_libdir" - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" - else - dnl The -rpath options are cumulative. - for found_dir in $rpathdirs; do - acl_saved_libdir="$libdir" - libdir="$found_dir" - eval flag=\"$acl_hardcode_libdir_flag_spec\" - libdir="$acl_saved_libdir" - LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" - done - fi - fi - if test "X$ltrpathdirs" != "X"; then - dnl When using libtool, the option that works for both libraries and - dnl executables is -R. The -R options are cumulative. - for found_dir in $ltrpathdirs; do - LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" - done - fi - popdef([PACKLIBS]) - popdef([PACKUP]) - popdef([PACK]) - popdef([NAME]) -]) -m4trace:gnulib-m4/lib-link.m4:718: -1- AC_DEFUN([AC_LIB_APPENDTOVAR], [ - for element in [$2]; do - haveit= - for x in $[$1]; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X$element"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - [$1]="${[$1]}${[$1]:+ }$element" - fi - done -]) -m4trace:gnulib-m4/lib-link.m4:742: -1- AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS], [ - AC_REQUIRE([AC_LIB_RPATH]) - AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) - $1= - if test "$enable_rpath" != no; then - if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then - dnl Use an explicit option to hardcode directories into the resulting - dnl binary. - rpathdirs= - next= - for opt in $2; do - if test -n "$next"; then - dir="$next" - dnl No need to hardcode the standard /usr/lib. - if test "X$dir" != "X/usr/$acl_libdirstem" \ - && test "X$dir" != "X/usr/$acl_libdirstem2" \ - && test "X$dir" != "X/usr/$acl_libdirstem3"; then - rpathdirs="$rpathdirs $dir" - fi - next= - else - case $opt in - -L) next=yes ;; - -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'` - dnl No need to hardcode the standard /usr/lib. - if test "X$dir" != "X/usr/$acl_libdirstem" \ - && test "X$dir" != "X/usr/$acl_libdirstem2" \ - && test "X$dir" != "X/usr/$acl_libdirstem3"; then - rpathdirs="$rpathdirs $dir" - fi - next= ;; - *) next= ;; - esac - fi - done - if test "X$rpathdirs" != "X"; then - if test -n ""$3""; then - dnl libtool is used for linking. Use -R options. - for dir in $rpathdirs; do - $1="${$1}${$1:+ }-R$dir" - done - else - dnl The linker is used for linking directly. - if test -n "$acl_hardcode_libdir_separator"; then - dnl Weird platform: only the last -rpath option counts, the user - dnl must pass all path elements in one option. - alldirs= - for dir in $rpathdirs; do - alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir" - done - acl_saved_libdir="$libdir" - libdir="$alldirs" - eval flag=\"$acl_hardcode_libdir_flag_spec\" - libdir="$acl_saved_libdir" - $1="$flag" - else - dnl The -rpath options are cumulative. - for dir in $rpathdirs; do - acl_saved_libdir="$libdir" - libdir="$dir" - eval flag=\"$acl_hardcode_libdir_flag_spec\" - libdir="$acl_saved_libdir" - $1="${$1}${$1:+ }$flag" - done - fi - fi - fi - fi - fi - AC_SUBST([$1]) -]) -m4trace:gnulib-m4/lib-prefix.m4:15: -1- AC_DEFUN([AC_LIB_PREFIX], [ - AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) - AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) - dnl By default, look in $includedir and $libdir. - use_additional=yes - AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - ]) - AC_ARG_WITH([lib-prefix], -[[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib - --without-lib-prefix don't search for libraries in includedir and libdir]], -[ - if test "X$withval" = "Xno"; then - use_additional=no - else - if test "X$withval" = "X"; then - AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - ]) - else - additional_includedir="$withval/include" - additional_libdir="$withval/$acl_libdirstem" - fi - fi -]) - if test $use_additional = yes; then - dnl Potentially add $additional_includedir to $CPPFLAGS. - dnl But don't add it - dnl 1. if it's the standard /usr/include, - dnl 2. if it's already present in $CPPFLAGS, - dnl 3. if it's /usr/local/include and we are using GCC on Linux, - dnl 4. if it doesn't exist as a directory. - if test "X$additional_includedir" != "X/usr/include"; then - haveit= - for x in $CPPFLAGS; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-I$additional_includedir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - if test "X$additional_includedir" = "X/usr/local/include"; then - if test -n "$GCC"; then - case $host_os in - linux* | gnu* | k*bsd*-gnu) haveit=yes;; - esac - fi - fi - if test -z "$haveit"; then - if test -d "$additional_includedir"; then - dnl Really add $additional_includedir to $CPPFLAGS. - CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" - fi - fi - fi - fi - dnl Potentially add $additional_libdir to $LDFLAGS. - dnl But don't add it - dnl 1. if it's the standard /usr/lib, - dnl 2. if it's already present in $LDFLAGS, - dnl 3. if it's /usr/local/lib and we are using GCC on Linux, - dnl 4. if it doesn't exist as a directory. - if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then - haveit= - for x in $LDFLAGS; do - AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) - if test "X$x" = "X-L$additional_libdir"; then - haveit=yes - break - fi - done - if test -z "$haveit"; then - if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then - if test -n "$GCC"; then - case $host_os in - linux*) haveit=yes;; - esac - fi - fi - if test -z "$haveit"; then - if test -d "$additional_libdir"; then - dnl Really add $additional_libdir to $LDFLAGS. - LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" - fi - fi - fi - fi - fi -]) -m4trace:gnulib-m4/lib-prefix.m4:115: -1- AC_DEFUN([AC_LIB_PREPARE_PREFIX], [ - dnl Unfortunately, prefix and exec_prefix get only finally determined - dnl at the end of configure. - if test "X$prefix" = "XNONE"; then - acl_final_prefix="$ac_default_prefix" - else - acl_final_prefix="$prefix" - fi - if test "X$exec_prefix" = "XNONE"; then - acl_final_exec_prefix='${prefix}' - else - acl_final_exec_prefix="$exec_prefix" - fi - acl_saved_prefix="$prefix" - prefix="$acl_final_prefix" - eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" - prefix="$acl_saved_prefix" -]) -m4trace:gnulib-m4/lib-prefix.m4:138: -1- AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], [ - acl_saved_prefix="$prefix" - prefix="$acl_final_prefix" - acl_saved_exec_prefix="$exec_prefix" - exec_prefix="$acl_final_exec_prefix" - $1 - exec_prefix="$acl_saved_exec_prefix" - prefix="$acl_saved_prefix" -]) -m4trace:gnulib-m4/lib-prefix.m4:155: -1- AC_DEFUN([AC_LIB_PREPARE_MULTILIB], [ - dnl There is no formal standard regarding lib, lib32, and lib64. - dnl On most glibc systems, the current practice is that on a system supporting - dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under - dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. However, on - dnl Arch Linux based distributions, it's the opposite: 32-bit libraries go - dnl under $prefix/lib32 and 64-bit libraries go under $prefix/lib. - dnl We determine the compiler's default mode by looking at the compiler's - dnl library search path. If at least one of its elements ends in /lib64 or - dnl points to a directory whose absolute pathname ends in /lib64, we use that - dnl for 64-bit ABIs. Similarly for 32-bit ABIs. Otherwise we use the default, - dnl namely "lib". - dnl On Solaris systems, the current practice is that on a system supporting - dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under - dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or - dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib. - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_HOST_CPU_C_ABI_32BIT]) - - AC_CACHE_CHECK([for ELF binary format], [gl_cv_elf], - [AC_EGREP_CPP([Extensible Linking Format], - [#if defined __ELF__ || (defined __linux__ && defined __EDG__) - Extensible Linking Format - #endif - ], - [gl_cv_elf=yes], - [gl_cv_elf=no]) - ]) - if test $gl_cv_elf = yes; then - # Extract the ELF class of a file (5th byte) in decimal. - # Cf. https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header - if od -A x < /dev/null >/dev/null 2>/dev/null; then - # Use POSIX od. - func_elfclass () - { - od -A n -t d1 -j 4 -N 1 - } - else - # Use BSD hexdump. - func_elfclass () - { - dd bs=1 count=1 skip=4 2>/dev/null | hexdump -e '1/1 "%3d "' - echo - } - fi - # Use 'expr', not 'test', to compare the values of func_elfclass, because on - # Solaris 11 OpenIndiana and Solaris 11 OmniOS, the result is 001 or 002, - # not 1 or 2. -changequote(,)dnl - case $HOST_CPU_C_ABI_32BIT in - yes) - # 32-bit ABI. - acl_is_expected_elfclass () - { - expr "`func_elfclass | sed -e 's/[ ]//g'`" = 1 > /dev/null - } - ;; - no) - # 64-bit ABI. - acl_is_expected_elfclass () - { - expr "`func_elfclass | sed -e 's/[ ]//g'`" = 2 > /dev/null - } - ;; - *) - # Unknown. - acl_is_expected_elfclass () - { - : - } - ;; - esac -changequote([,])dnl - else - acl_is_expected_elfclass () - { - : - } - fi - - dnl Allow the user to override the result by setting acl_cv_libdirstems. - AC_CACHE_CHECK([for the common suffixes of directories in the library search path], - [acl_cv_libdirstems], - [dnl Try 'lib' first, because that's the default for libdir in GNU, see - dnl . - acl_libdirstem=lib - acl_libdirstem2= - acl_libdirstem3= - case "$host_os" in - solaris*) - dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment - dnl . - dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link." - dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the - dnl symlink is missing, so we set acl_libdirstem2 too. - if test $HOST_CPU_C_ABI_32BIT = no; then - acl_libdirstem2=lib/64 - case "$host_cpu" in - sparc*) acl_libdirstem3=lib/sparcv9 ;; - i*86 | x86_64) acl_libdirstem3=lib/amd64 ;; - esac - fi - ;; - netbsd*) - dnl On NetBSD/sparc64, there is a 'sparc' subdirectory that contains - dnl 32-bit libraries. - if test $HOST_CPU_C_ABI_32BIT != no; then - case "$host_cpu" in - sparc*) acl_libdirstem2=lib/sparc ;; - esac - fi - ;; - *) - dnl If $CC generates code for a 32-bit ABI, the libraries are - dnl surely under $prefix/lib or $prefix/lib32, not $prefix/lib64. - dnl Similarly, if $CC generates code for a 64-bit ABI, the libraries - dnl are surely under $prefix/lib or $prefix/lib64, not $prefix/lib32. - dnl Find the compiler's search path. However, non-system compilers - dnl sometimes have odd library search paths. But we can't simply invoke - dnl '/usr/bin/gcc -print-search-dirs' because that would not take into - dnl account the -m32/-m31 or -m64 options from the $CC or $CFLAGS. - searchpath=`(LC_ALL=C $CC $CPPFLAGS $CFLAGS -print-search-dirs) 2>/dev/null \ - | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'` - if test $HOST_CPU_C_ABI_32BIT != no; then - # 32-bit or unknown ABI. - if test -d /usr/lib32; then - acl_libdirstem2=lib32 - fi - fi - if test $HOST_CPU_C_ABI_32BIT != yes; then - # 64-bit or unknown ABI. - if test -d /usr/lib64; then - acl_libdirstem3=lib64 - fi - fi - if test -n "$searchpath"; then - acl_saved_IFS="${IFS= }"; IFS=":" - for searchdir in $searchpath; do - if test -d "$searchdir"; then - case "$searchdir" in - */lib32/ | */lib32 ) acl_libdirstem2=lib32 ;; - */lib64/ | */lib64 ) acl_libdirstem3=lib64 ;; - */../ | */.. ) - # Better ignore directories of this form. They are misleading. - ;; - *) searchdir=`cd "$searchdir" && pwd` - case "$searchdir" in - */lib32 ) acl_libdirstem2=lib32 ;; - */lib64 ) acl_libdirstem3=lib64 ;; - esac ;; - esac - fi - done - IFS="$acl_saved_IFS" - if test $HOST_CPU_C_ABI_32BIT = yes; then - # 32-bit ABI. - acl_libdirstem3= - fi - if test $HOST_CPU_C_ABI_32BIT = no; then - # 64-bit ABI. - acl_libdirstem2= - fi - fi - ;; - esac - test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem" - test -n "$acl_libdirstem3" || acl_libdirstem3="$acl_libdirstem" - acl_cv_libdirstems="$acl_libdirstem,$acl_libdirstem2,$acl_libdirstem3" - ]) - dnl Decompose acl_cv_libdirstems into acl_libdirstem, acl_libdirstem2, and - dnl acl_libdirstem3. -changequote(,)dnl - acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'` - acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,//' -e 's/,.*//'` - acl_libdirstem3=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,[^,]*,//' -e 's/,.*//'` -changequote([,])dnl -]) -m4trace:gnulib-m4/libunistring-base.m4:24: -1- AC_DEFUN([gl_LIBUNISTRING_MODULE], [ - AC_REQUIRE([gl_LIBUNISTRING_LIB_PREPARE]) - dnl Use the variables HAVE_LIBUNISTRING, LIBUNISTRING_VERSION from - dnl gl_LIBUNISTRING_CORE if that macro has been run. - gl_CONDITIONAL(AS_TR_CPP([LIBUNISTRING_COMPILE_$2]), - [gl_LIBUNISTRING_VERSION_CMP([$1])]) -]) -m4trace:gnulib-m4/libunistring-base.m4:52: -1- AC_DEFUN([gl_LIBUNISTRING_MODULE_WITH_VARIABLE], [ - gl_LIBUNISTRING_MODULE([$1], [$2]) - m4_ifndef([gl_IN_LIBUNISTRING], - [if test -z "${AS_TR_CPP([LIBUNISTRING_COMPILE_$2])_TRUE}"; then - GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]AS_TR_CPP([$2_DLL_VARIABLE])= - fi - ]) -]) -m4trace:gnulib-m4/libunistring-base.m4:79: -1- AC_DEFUN([gl_LIBUNISTRING_LIBHEADER], [ - AC_REQUIRE([gl_LIBUNISTRING_LIB_PREPARE]) - dnl Use the variables HAVE_LIBUNISTRING, LIBUNISTRING_VERSION from - dnl gl_LIBUNISTRING_CORE if that macro has been run. - if gl_LIBUNISTRING_VERSION_CMP([$1]); then - dnl It is OK to use a .h file in lib/ from within tests/, but not vice - dnl versa. - if test -z "$LIBUNISTRING_[]AS_TR_CPP([$2])"; then - LIBUNISTRING_[]AS_TR_CPP([$2])="${gl_source_base_prefix}$2" - fi - else - LIBUNISTRING_[]AS_TR_CPP([$2])= - fi - AC_SUBST([LIBUNISTRING_]AS_TR_CPP([$2])) -]) -m4trace:gnulib-m4/libunistring-base.m4:98: -1- AC_DEFUN([gl_LIBUNISTRING_LIB_PREPARE], [ - dnl Ensure that HAVE_LIBUNISTRING is fully determined at this point. - m4_ifdef([gl_LIBUNISTRING], [AC_REQUIRE([gl_LIBUNISTRING])]) - - AC_REQUIRE([AC_PROG_AWK]) - -dnl Sed expressions to extract the parts of a version number. -changequote(,) -gl_libunistring_sed_extract_major='/^[0-9]/{s/^\([0-9]*\).*/\1/p;q;} -i\ -0 -q -' -gl_libunistring_sed_extract_minor='/^[0-9][0-9]*[.][0-9]/{s/^[0-9]*[.]\([0-9]*\).*/\1/p;q;} -i\ -0 -q -' -gl_libunistring_sed_extract_subminor='/^[0-9][0-9]*[.][0-9][0-9]*[.][0-9]/{s/^[0-9]*[.][0-9]*[.]\([0-9]*\).*/\1/p;q;} -i\ -0 -q -' -changequote([,]) - - if test "$HAVE_LIBUNISTRING" = yes; then - LIBUNISTRING_VERSION_MAJOR=`echo "$LIBUNISTRING_VERSION" | sed -n -e "$gl_libunistring_sed_extract_major"` - LIBUNISTRING_VERSION_MINOR=`echo "$LIBUNISTRING_VERSION" | sed -n -e "$gl_libunistring_sed_extract_minor"` - LIBUNISTRING_VERSION_SUBMINOR=`echo "$LIBUNISTRING_VERSION" | sed -n -e "$gl_libunistring_sed_extract_subminor"` - fi - - dnl Determine whether from an installed libunistring - dnl is available. - m4_ifdef([gl_IN_LIBUNISTRING], - [dnl In libunistring, all .h files that declare variables need to - dnl #include . This references the file - dnl unistring/woe32dll.h in libunistring. - HAVE_UNISTRING_WOE32DLL_H=1 - ], - [dnl In gnulib or in applications, we need a #include - dnl if and only if an installed libunistring is available. - if test "$HAVE_LIBUNISTRING" = yes; then - AC_CHECK_HEADERS([unistring/woe32dll.h], - [HAVE_UNISTRING_WOE32DLL_H=1], - [HAVE_UNISTRING_WOE32DLL_H=0]) - else - HAVE_UNISTRING_WOE32DLL_H=0 - fi - ]) - AC_SUBST([HAVE_UNISTRING_WOE32DLL_H]) -]) -m4trace:gnulib-m4/libunistring-base.m4:154: -1- AC_DEFUN([gl_LIBUNISTRING_VERSION_CMP], [ { test "$HAVE_LIBUNISTRING" != yes \ - || { - dnl AS_LITERAL_IF exists and works fine since autoconf-2.59 at least. - AS_LITERAL_IF([$1], - [dnl This is the optimized variant, that assumes the argument is a literal: - m4_pushdef([requested_version_major], - [gl_LIBUNISTRING_ARG_OR_ZERO(m4_bpatsubst([$1], [^\([0-9]*\).*], [\1]), [])]) - m4_pushdef([requested_version_minor], - [gl_LIBUNISTRING_ARG_OR_ZERO(m4_bpatsubst([$1], [^[0-9]*[.]\([0-9]*\).*], [\1]), [$1])]) - m4_pushdef([requested_version_subminor], - [gl_LIBUNISTRING_ARG_OR_ZERO(m4_bpatsubst([$1], [^[0-9]*[.][0-9]*[.]\([0-9]*\).*], [\1]), [$1])]) - test $LIBUNISTRING_VERSION_MAJOR -lt requested_version_major \ - || { test $LIBUNISTRING_VERSION_MAJOR -eq requested_version_major \ - && { test $LIBUNISTRING_VERSION_MINOR -lt requested_version_minor \ - || { test $LIBUNISTRING_VERSION_MINOR -eq requested_version_minor \ - && test $LIBUNISTRING_VERSION_SUBMINOR -lt requested_version_subminor - } - } - } - m4_popdef([requested_version_subminor]) - m4_popdef([requested_version_minor]) - m4_popdef([requested_version_major]) - ], - [dnl This is the unoptimized variant: - requested_version_major=`echo '$1' | sed -n -e "$gl_libunistring_sed_extract_major"` - requested_version_minor=`echo '$1' | sed -n -e "$gl_libunistring_sed_extract_minor"` - requested_version_subminor=`echo '$1' | sed -n -e "$gl_libunistring_sed_extract_subminor"` - test $LIBUNISTRING_VERSION_MAJOR -lt $requested_version_major \ - || { test $LIBUNISTRING_VERSION_MAJOR -eq $requested_version_major \ - && { test $LIBUNISTRING_VERSION_MINOR -lt $requested_version_minor \ - || { test $LIBUNISTRING_VERSION_MINOR -eq $requested_version_minor \ - && test $LIBUNISTRING_VERSION_SUBMINOR -lt $requested_version_subminor - } - } - } - ]) - } - }]) -m4trace:gnulib-m4/limits-h.m4:10: -1- AC_DEFUN_ONCE([gl_LIMITS_H], [ - gl_CHECK_NEXT_HEADERS([limits.h]) - - AC_CACHE_CHECK([whether limits.h has WORD_BIT, BOOL_WIDTH etc.], - [gl_cv_header_limits_width], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#ifndef __STDC_WANT_IEC_60559_BFP_EXT__ - #define __STDC_WANT_IEC_60559_BFP_EXT__ 1 - #endif - #include - long long llm = LLONG_MAX; - int wb = WORD_BIT; - int ullw = ULLONG_WIDTH; - int bw = BOOL_WIDTH; - int bm = BOOL_MAX; - int mblm = MB_LEN_MAX; - ]])], - [gl_cv_header_limits_width=yes], - [gl_cv_header_limits_width=no])]) - GL_GENERATE_LIMITS_H=true - AS_IF([test "$gl_cv_header_limits_width" = yes], - [AC_CACHE_CHECK([whether limits.h has SSIZE_MAX], - [gl_cv_header_limits_ssize_max], - [AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#include - #ifndef SSIZE_MAX - #error "SSIZE_MAX is not defined" - #endif - ]])], - [gl_cv_header_limits_ssize_max=yes], - [gl_cv_header_limits_ssize_max=no])]) - if test "$gl_cv_header_limits_ssize_max" = yes; then - GL_GENERATE_LIMITS_H=false - fi]) -]) -m4trace:gnulib-m4/limits-h.m4:50: -1- AC_DEFUN([gl_REPLACE_LIMITS_H], [ - AC_REQUIRE([gl_LIMITS_H]) - GL_GENERATE_LIMITS_H=true -]) -m4trace:gnulib-m4/localcharset.m4:7: -1- AC_DEFUN([gl_LOCALCHARSET], [ - dnl Prerequisites of lib/localcharset.c. - AC_REQUIRE([AM_LANGINFO_CODESET]) -]) -m4trace:gnulib-m4/locale-fr.m4:10: -1- AC_DEFUN_ONCE([gt_LOCALE_FR], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([AM_LANGINFO_CODESET]) - AC_CACHE_CHECK([for a traditional french locale], [gt_cv_locale_fr], [ - AC_LANG_CONFTEST([AC_LANG_SOURCE([[ -#include -#include -#if HAVE_LANGINFO_CODESET -# include -#endif -#include -#include -struct tm t; -char buf[16]; -int main () { - /* On BeOS and Haiku, locales are not implemented in libc. Rather, libintl - imitates locale dependent behaviour by looking at the environment - variables, and all locales use the UTF-8 encoding. */ -#if defined __BEOS__ || defined __HAIKU__ - return 1; -#else - /* Check whether the given locale name is recognized by the system. */ -# if defined _WIN32 && !defined __CYGWIN__ - /* On native Windows, setlocale(category, "") looks at the system settings, - not at the environment variables. Also, when an encoding suffix such - as ".65001" or ".54936" is specified, it succeeds but sets the LC_CTYPE - category of the locale to "C". */ - if (setlocale (LC_ALL, getenv ("LC_ALL")) == NULL - || strcmp (setlocale (LC_CTYPE, NULL), "C") == 0) - return 1; -# else - if (setlocale (LC_ALL, "") == NULL) return 1; -# endif - /* Check whether nl_langinfo(CODESET) is nonempty and not "ASCII" or "646". - On Mac OS X 10.3.5 (Darwin 7.5) in the fr_FR locale, nl_langinfo(CODESET) - is empty, and the behaviour of Tcl 8.4 in this locale is not useful. - On OpenBSD 4.0, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "646". In this situation, - some unit tests fail. - On MirBSD 10, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "UTF-8". */ -# if HAVE_LANGINFO_CODESET - { - const char *cs = nl_langinfo (CODESET); - if (cs[0] == '\0' || strcmp (cs, "ASCII") == 0 || strcmp (cs, "646") == 0 - || strcmp (cs, "UTF-8") == 0) - return 1; - } -# endif -# ifdef __CYGWIN__ - /* On Cygwin, avoid locale names without encoding suffix, because the - locale_charset() function relies on the encoding suffix. Note that - LC_ALL is set on the command line. */ - if (strchr (getenv ("LC_ALL"), '.') == NULL) return 1; -# endif - /* Check whether in the abbreviation of the second month, the second - character (should be U+00E9: LATIN SMALL LETTER E WITH ACUTE) is only - one byte long. This excludes the UTF-8 encoding. */ - t.tm_year = 1975 - 1900; t.tm_mon = 2 - 1; t.tm_mday = 4; - if (strftime (buf, sizeof (buf), "%b", &t) < 3 || buf[2] != 'v') return 1; -# if !defined __BIONIC__ /* Bionic libc's 'struct lconv' is just a dummy. */ - /* Check whether the decimal separator is a comma. - On NetBSD 3.0 in the fr_FR.ISO8859-1 locale, localeconv()->decimal_point - are nl_langinfo(RADIXCHAR) are both ".". */ - if (localeconv () ->decimal_point[0] != ',') return 1; -# endif - return 0; -#endif -} - ]])]) - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - case "$host_os" in - # Handle native Windows specially, because there setlocale() interprets - # "ar" as "Arabic" or "Arabic_Saudi Arabia.1256", - # "fr" or "fra" as "French" or "French_France.1252", - # "ge"(!) or "deu"(!) as "German" or "German_Germany.1252", - # "ja" as "Japanese" or "Japanese_Japan.932", - # and similar. - mingw* | windows*) - # Test for the native Windows locale name. - if (LC_ALL=French_France.1252 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=French_France.1252 - else - # None found. - gt_cv_locale_fr=none - fi - ;; - *) - # Setting LC_ALL is not enough. Need to set LC_TIME to empty, because - # otherwise on Mac OS X 10.3.5 the LC_TIME=C from the beginning of the - # configure script would override the LC_ALL setting. Likewise for - # LC_CTYPE, which is also set at the beginning of the configure script. - # Test for the usual locale name. - if (LC_ALL=fr_FR LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=fr_FR - else - # Test for the locale name with explicit encoding suffix. - if (LC_ALL=fr_FR.ISO-8859-1 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=fr_FR.ISO-8859-1 - else - # Test for the AIX, OSF/1, FreeBSD, NetBSD, OpenBSD locale name. - if (LC_ALL=fr_FR.ISO8859-1 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=fr_FR.ISO8859-1 - else - # Test for the HP-UX locale name. - if (LC_ALL=fr_FR.iso88591 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=fr_FR.iso88591 - else - # Test for the Solaris 7 locale name. - if (LC_ALL=fr LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr=fr - else - # None found. - gt_cv_locale_fr=none - fi - fi - fi - fi - fi - ;; - esac - fi - rm -fr conftest* - ]) - LOCALE_FR=$gt_cv_locale_fr - case $LOCALE_FR in #( - '' | *[[[:space:]\"\$\'*@<:@]]*) - dnl This locale name might cause trouble with sh or make. - AC_MSG_WARN([invalid locale "$LOCALE_FR"; assuming "none"]) - LOCALE_FR=none;; - esac - AC_SUBST([LOCALE_FR]) -]) -m4trace:gnulib-m4/locale-fr.m4:146: -1- AC_DEFUN_ONCE([gt_LOCALE_FR_UTF8], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([AM_LANGINFO_CODESET]) - AC_CACHE_CHECK([for a french Unicode locale], [gt_cv_locale_fr_utf8], [ - case "$host_os" in - *-musl* | midipix*) - dnl On musl libc, all kinds of ll_CC.UTF-8 locales exist, even without - dnl any locale file on disk. But they are effectively equivalent to the - dnl C.UTF-8 locale, except for locale categories (such as LC_MESSSAGES) - dnl for which localizations (.mo files) have been installed. - gt_cv_locale_fr_utf8=fr_FR.UTF-8 - ;; - *) - AC_LANG_CONFTEST([AC_LANG_SOURCE([[ -#include -#include -#if HAVE_LANGINFO_CODESET -# include -#endif -#include -#include -struct tm t; -char buf[16]; -int main () { - /* On BeOS and Haiku, locales are not implemented in libc. Rather, libintl - imitates locale dependent behaviour by looking at the environment - variables, and all locales use the UTF-8 encoding. */ -#if !(defined __BEOS__ || defined __HAIKU__) - /* Check whether the given locale name is recognized by the system. */ -# if defined _WIN32 && !defined __CYGWIN__ - /* On native Windows, setlocale(category, "") looks at the system settings, - not at the environment variables. Also, when an encoding suffix such - as ".65001" or ".54936" is specified, it succeeds but sets the LC_CTYPE - category of the locale to "C". */ - if (setlocale (LC_ALL, getenv ("LC_ALL")) == NULL - || strcmp (setlocale (LC_CTYPE, NULL), "C") == 0) - return 1; -# else - if (setlocale (LC_ALL, "") == NULL) return 1; -# endif - /* Check whether nl_langinfo(CODESET) is nonempty and not "ASCII" or "646". - On Mac OS X 10.3.5 (Darwin 7.5) in the fr_FR locale, nl_langinfo(CODESET) - is empty, and the behaviour of Tcl 8.4 in this locale is not useful. - On OpenBSD 4.0, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "646". In this situation, - some unit tests fail. */ -# if HAVE_LANGINFO_CODESET - { - const char *cs = nl_langinfo (CODESET); - if (cs[0] == '\0' || strcmp (cs, "ASCII") == 0 || strcmp (cs, "646") == 0) - return 1; - } -# endif -# ifdef __CYGWIN__ - /* On Cygwin, avoid locale names without encoding suffix, because the - locale_charset() function relies on the encoding suffix. Note that - LC_ALL is set on the command line. */ - if (strchr (getenv ("LC_ALL"), '.') == NULL) return 1; -# endif - /* Check whether in the abbreviation of the second month, the second - character (should be U+00E9: LATIN SMALL LETTER E WITH ACUTE) is - two bytes long, with UTF-8 encoding. */ - t.tm_year = 1975 - 1900; t.tm_mon = 2 - 1; t.tm_mday = 4; - if (strftime (buf, sizeof (buf), "%b", &t) < 4 - || buf[1] != (char) 0xc3 || buf[2] != (char) 0xa9 || buf[3] != 'v') - return 1; -#endif -#if !defined __BIONIC__ /* Bionic libc's 'struct lconv' is just a dummy. */ - /* Check whether the decimal separator is a comma. - On NetBSD 3.0 in the fr_FR.ISO8859-1 locale, localeconv()->decimal_point - are nl_langinfo(RADIXCHAR) are both ".". */ - if (localeconv () ->decimal_point[0] != ',') return 1; -#endif - return 0; -} - ]])]) - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - case "$host_os" in - # Handle native Windows specially, because there setlocale() interprets - # "ar" as "Arabic" or "Arabic_Saudi Arabia.1256", - # "fr" or "fra" as "French" or "French_France.1252", - # "ge"(!) or "deu"(!) as "German" or "German_Germany.1252", - # "ja" as "Japanese" or "Japanese_Japan.932", - # and similar. - mingw* | windows*) - # Test for the hypothetical native Windows locale name. - if (LC_ALL=French_France.65001 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr_utf8=French_France.65001 - else - # None found. - gt_cv_locale_fr_utf8=none - fi - ;; - *) - # Setting LC_ALL is not enough. Need to set LC_TIME to empty, because - # otherwise on Mac OS X 10.3.5 the LC_TIME=C from the beginning of the - # configure script would override the LC_ALL setting. Likewise for - # LC_CTYPE, which is also set at the beginning of the configure script. - # Test for the usual locale name. - if (LC_ALL=fr_FR LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr_utf8=fr_FR - else - # Test for the locale name with explicit encoding suffix. - if (LC_ALL=fr_FR.UTF-8 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr_utf8=fr_FR.UTF-8 - else - # Test for the Solaris 7 locale name. - if (LC_ALL=fr.UTF-8 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_fr_utf8=fr.UTF-8 - else - # None found. - gt_cv_locale_fr_utf8=none - fi - fi - fi - ;; - esac - fi - rm -fr conftest* - ;; - esac - ]) - LOCALE_FR_UTF8=$gt_cv_locale_fr_utf8 - case $LOCALE_FR_UTF8 in #( - '' | *[[[:space:]\"\$\'*@<:@]]*) - dnl This locale name might cause trouble with sh or make. - AC_MSG_WARN([invalid locale "$LOCALE_FR_UTF8"; assuming "none"]) - LOCALE_FR_UTF8=none;; - esac - AC_SUBST([LOCALE_FR_UTF8]) - - dnl Users of $LOCALE_FR_UTF8 need to know which of the locale categories they - dnl can rely on. - case "$host_os" in - *-musl* | midipix*) - dnl On musl libc, locale categories other than LC_CTYPE and LC_MESSAGES - dnl are effectively unimplemented. - LC_COLLATE_IMPLEMENTED=false - LC_NUMERIC_IMPLEMENTED=false - LC_TIME_IMPLEMENTED=false - LC_MONETARY_IMPLEMENTED=false - ;; - *) - LC_COLLATE_IMPLEMENTED=true - LC_NUMERIC_IMPLEMENTED=true - LC_TIME_IMPLEMENTED=true - LC_MONETARY_IMPLEMENTED=true - ;; - esac - AC_SUBST([LC_COLLATE_IMPLEMENTED]) - AC_SUBST([LC_NUMERIC_IMPLEMENTED]) - AC_SUBST([LC_TIME_IMPLEMENTED]) - AC_SUBST([LC_MONETARY_IMPLEMENTED]) -]) -m4trace:gnulib-m4/locale-ja.m4:10: -1- AC_DEFUN_ONCE([gt_LOCALE_JA], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([AM_LANGINFO_CODESET]) - AC_CACHE_CHECK([for a traditional japanese locale], [gt_cv_locale_ja], [ - AC_LANG_CONFTEST([AC_LANG_SOURCE([[ -#include -#include -#if HAVE_LANGINFO_CODESET -# include -#endif -#include -#include -struct tm t; -char buf[16]; -int main () -{ - /* On BeOS and Haiku, locales are not implemented in libc. Rather, libintl - imitates locale dependent behaviour by looking at the environment - variables, and all locales use the UTF-8 encoding. */ -#if defined __BEOS__ || defined __HAIKU__ - return 1; -#else - /* Check whether the given locale name is recognized by the system. */ -# if defined _WIN32 && !defined __CYGWIN__ - /* On native Windows, setlocale(category, "") looks at the system settings, - not at the environment variables. Also, when an encoding suffix such - as ".65001" or ".54936" is specified, it succeeds but sets the LC_CTYPE - category of the locale to "C". */ - if (setlocale (LC_ALL, getenv ("LC_ALL")) == NULL - || strcmp (setlocale (LC_CTYPE, NULL), "C") == 0) - return 1; -# else - if (setlocale (LC_ALL, "") == NULL) return 1; -# endif - /* Check whether nl_langinfo(CODESET) is nonempty and not "ASCII" or "646". - On Mac OS X 10.3.5 (Darwin 7.5) in the fr_FR locale, nl_langinfo(CODESET) - is empty, and the behaviour of Tcl 8.4 in this locale is not useful. - On OpenBSD 4.0, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "646". In this situation, - some unit tests fail. - On MirBSD 10, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "UTF-8". */ -# if HAVE_LANGINFO_CODESET - { - const char *cs = nl_langinfo (CODESET); - if (cs[0] == '\0' || strcmp (cs, "ASCII") == 0 || strcmp (cs, "646") == 0 - || strcmp (cs, "UTF-8") == 0) - return 1; - } -# endif -# ifdef __CYGWIN__ - /* On Cygwin, avoid locale names without encoding suffix, because the - locale_charset() function relies on the encoding suffix. Note that - LC_ALL is set on the command line. */ - if (strchr (getenv ("LC_ALL"), '.') == NULL) return 1; -# endif - /* Check whether MB_CUR_MAX is > 1. This excludes the dysfunctional locales - on Cygwin 1.5.x. */ - if (MB_CUR_MAX == 1) - return 1; - /* Check whether in a month name, no byte in the range 0x80..0x9F occurs. - This excludes the UTF-8 encoding (except on MirBSD). */ - { - const char *p; - t.tm_year = 1975 - 1900; t.tm_mon = 2 - 1; t.tm_mday = 4; - if (strftime (buf, sizeof (buf), "%B", &t) < 2) return 1; - for (p = buf; *p != '\0'; p++) - if ((unsigned char) *p >= 0x80 && (unsigned char) *p < 0xa0) - return 1; - } - return 0; -#endif -} - ]])]) - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - case "$host_os" in - # Handle native Windows specially, because there setlocale() interprets - # "ar" as "Arabic" or "Arabic_Saudi Arabia.1256", - # "fr" or "fra" as "French" or "French_France.1252", - # "ge"(!) or "deu"(!) as "German" or "German_Germany.1252", - # "ja" as "Japanese" or "Japanese_Japan.932", - # and similar. - mingw* | windows*) - # Note that on native Windows, the Japanese locale is - # Japanese_Japan.932, and CP932 is very different from EUC-JP, so we - # cannot use it here. - gt_cv_locale_ja=none - ;; - *) - # Setting LC_ALL is not enough. Need to set LC_TIME to empty, because - # otherwise on Mac OS X 10.3.5 the LC_TIME=C from the beginning of the - # configure script would override the LC_ALL setting. Likewise for - # LC_CTYPE, which is also set at the beginning of the configure script. - # Test for the AIX locale name. - if (LC_ALL=ja_JP LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_ja=ja_JP - else - # Test for the locale name with explicit encoding suffix. - if (LC_ALL=ja_JP.EUC-JP LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_ja=ja_JP.EUC-JP - else - # Test for the HP-UX, OSF/1, NetBSD locale name. - if (LC_ALL=ja_JP.eucJP LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_ja=ja_JP.eucJP - else - # Test for the IRIX, FreeBSD locale name. - if (LC_ALL=ja_JP.EUC LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_ja=ja_JP.EUC - else - # Test for the Solaris 7 locale name. - if (LC_ALL=ja LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_ja=ja - else - # Special test for NetBSD 1.6. - if test -f /usr/share/locale/ja_JP.eucJP/LC_CTYPE; then - gt_cv_locale_ja=ja_JP.eucJP - else - # None found. - gt_cv_locale_ja=none - fi - fi - fi - fi - fi - fi - ;; - esac - fi - rm -fr conftest* - ]) - LOCALE_JA=$gt_cv_locale_ja - case $LOCALE_JA in #( - '' | *[[[:space:]\"\$\'*@<:@]]*) - dnl This locale name might cause trouble with sh or make. - AC_MSG_WARN([invalid locale "$LOCALE_JA"; assuming "none"]) - LOCALE_JA=none;; - esac - AC_SUBST([LOCALE_JA]) -]) -m4trace:gnulib-m4/locale-zh.m4:10: -1- AC_DEFUN_ONCE([gt_LOCALE_ZH_CN], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([AM_LANGINFO_CODESET]) - AC_CACHE_CHECK([for a transitional chinese locale], [gt_cv_locale_zh_CN], [ - AC_LANG_CONFTEST([AC_LANG_SOURCE([[ -#include -#include -#include -#if HAVE_LANGINFO_CODESET -# include -#endif -#include -#include -struct tm t; -char buf[16]; -int main () -{ - /* On BeOS and Haiku, locales are not implemented in libc. Rather, libintl - imitates locale dependent behaviour by looking at the environment - variables, and all locales use the UTF-8 encoding. */ -#if defined __BEOS__ || defined __HAIKU__ - return 1; -#else - /* Check whether the given locale name is recognized by the system. */ -# if defined _WIN32 && !defined __CYGWIN__ - /* On native Windows, setlocale(category, "") looks at the system settings, - not at the environment variables. Also, when an encoding suffix such - as ".65001" or ".54936" is specified, it succeeds but sets the LC_CTYPE - category of the locale to "C". */ - if (setlocale (LC_ALL, getenv ("LC_ALL")) == NULL - || strcmp (setlocale (LC_CTYPE, NULL), "C") == 0) - return 1; -# else - if (setlocale (LC_ALL, "") == NULL) return 1; -# endif - /* Check whether nl_langinfo(CODESET) is nonempty and not "ASCII" or "646". - On Mac OS X 10.3.5 (Darwin 7.5) in the fr_FR locale, nl_langinfo(CODESET) - is empty, and the behaviour of Tcl 8.4 in this locale is not useful. - On OpenBSD 4.0, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "646". In this situation, - some unit tests fail. - On MirBSD 10, when an unsupported locale is specified, setlocale() - succeeds but then nl_langinfo(CODESET) is "UTF-8". */ -# if HAVE_LANGINFO_CODESET - { - const char *cs = nl_langinfo (CODESET); - if (cs[0] == '\0' || strcmp (cs, "ASCII") == 0 || strcmp (cs, "646") == 0 - || strcmp (cs, "UTF-8") == 0) - return 1; - } -# endif -# ifdef __CYGWIN__ - /* On Cygwin, avoid locale names without encoding suffix, because the - locale_charset() function relies on the encoding suffix. Note that - LC_ALL is set on the command line. */ - if (strchr (getenv ("LC_ALL"), '.') == NULL) return 1; -# endif - /* Check whether in a month name, no byte in the range 0x80..0x9F occurs. - This excludes the UTF-8 encoding (except on MirBSD). */ - { - const char *p; - t.tm_year = 1975 - 1900; t.tm_mon = 2 - 1; t.tm_mday = 4; - if (strftime (buf, sizeof (buf), "%B", &t) < 2) return 1; - for (p = buf; *p != '\0'; p++) - if ((unsigned char) *p >= 0x80 && (unsigned char) *p < 0xa0) - return 1; - } - /* Check whether a typical GB18030 multibyte sequence is recognized as a - single wide character. This excludes the GB2312 and GBK encodings. */ - if (mblen ("\203\062\332\066", 5) != 4) - return 1; - return 0; -#endif -} - ]])]) - if AC_TRY_EVAL([ac_link]) && test -s conftest$ac_exeext; then - case "$host_os" in - # Handle native Windows specially, because there setlocale() interprets - # "ar" as "Arabic" or "Arabic_Saudi Arabia.1256", - # "fr" or "fra" as "French" or "French_France.1252", - # "ge"(!) or "deu"(!) as "German" or "German_Germany.1252", - # "ja" as "Japanese" or "Japanese_Japan.932", - # and similar. - mingw* | windows*) - # Test for the hypothetical native Windows locale name. - if (LC_ALL=Chinese_China.54936 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_zh_CN=Chinese_China.54936 - else - # None found. - gt_cv_locale_zh_CN=none - fi - ;; - solaris2.8) - # On Solaris 8, the locales zh_CN.GB18030, zh_CN.GBK, zh.GBK are - # broken. One witness is the test case in gl_MBRTOWC_SANITYCHECK. - # Another witness is that "LC_ALL=zh_CN.GB18030 bash -c true" dumps core. - gt_cv_locale_zh_CN=none - ;; - *) - # Setting LC_ALL is not enough. Need to set LC_TIME to empty, because - # otherwise on Mac OS X 10.3.5 the LC_TIME=C from the beginning of the - # configure script would override the LC_ALL setting. Likewise for - # LC_CTYPE, which is also set at the beginning of the configure script. - # Test for the locale name without encoding suffix. - if (LC_ALL=zh_CN LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_zh_CN=zh_CN - else - # Test for the locale name with explicit encoding suffix. - if (LC_ALL=zh_CN.GB18030 LC_TIME= LC_CTYPE= ./conftest; exit) 2>/dev/null; then - gt_cv_locale_zh_CN=zh_CN.GB18030 - else - # None found. - gt_cv_locale_zh_CN=none - fi - fi - ;; - esac - else - # If there was a link error, due to mblen(), the system is so old that - # it certainly doesn't have a chinese locale. - gt_cv_locale_zh_CN=none - fi - rm -fr conftest* - ]) - LOCALE_ZH_CN=$gt_cv_locale_zh_CN - case $LOCALE_ZH_CN in #( - '' | *[[[:space:]\"\$\'*@<:@]]*) - dnl This locale name might cause trouble with sh or make. - AC_MSG_WARN([invalid locale "$LOCALE_ZH_CN"; assuming "none"]) - LOCALE_ZH_CN=none;; - esac - AC_SUBST([LOCALE_ZH_CN]) -]) -m4trace:gnulib-m4/locale_h.m4:7: -1- AC_DEFUN_ONCE([gl_LOCALE_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_LOCALE_H_DEFAULTS]) - - dnl Persuade glibc to define locale_t and the int_p_*, int_n_* - dnl members of 'struct lconv'. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - dnl If is replaced, then must also be replaced. - AC_REQUIRE([gl_STDDEF_H]) - - AC_REQUIRE([gl_LOCALE_T]) - - dnl Solaris 11.0 defines the int_p_*, int_n_* members of 'struct lconv' - dnl only if _LCONV_C99 is defined. - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - solaris*) - AC_DEFINE([_LCONV_C99], [1], [Define to 1 on Solaris.]) - ;; - esac - - AC_CACHE_CHECK([whether locale.h conforms to POSIX:2001], - [gl_cv_header_locale_h_posix2001], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - int x = LC_MESSAGES; - int y = sizeof (((struct lconv *) 0)->decimal_point);]], - [[]])], - [gl_cv_header_locale_h_posix2001=yes], - [gl_cv_header_locale_h_posix2001=no])]) - - dnl Check whether 'struct lconv' is complete. - dnl Bionic libc's 'struct lconv' is just a dummy. - dnl On OpenBSD 4.9, HP-UX 11, IRIX 6.5, OSF/1 5.1, Solaris 9, Cygwin 1.5.x, - dnl mingw, MSVC 9, it lacks the int_p_* and int_n_* members. - AC_CACHE_CHECK([whether struct lconv is properly defined], - [gl_cv_sys_struct_lconv_ok], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - struct lconv l; - int x = sizeof (l.decimal_point); - int y = sizeof (l.int_p_cs_precedes);]], - [[]])], - [gl_cv_sys_struct_lconv_ok=yes], - [gl_cv_sys_struct_lconv_ok=no]) - ]) - if test $gl_cv_sys_struct_lconv_ok = no; then - dnl On native Windows with MSVC, merely define these member names as macros. - dnl This avoids trouble in C++ mode. - case "$host_os" in - windows*-msvc*) - ;; - mingw* | windows*) - AC_EGREP_CPP([Special], [ -#ifdef _MSC_VER - Special -#endif - ], - [], - [REPLACE_STRUCT_LCONV=1]) - ;; - *) REPLACE_STRUCT_LCONV=1 ;; - esac - fi - - dnl is always overridden, because of GNULIB_POSIXCHECK. - gl_NEXT_HEADERS([locale.h]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[#include -/* Some systems provide declarations in a non-standard header. */ -#if HAVE_XLOCALE_H -# include -#endif - ]], - [setlocale newlocale duplocale freelocale]) -]) -m4trace:gnulib-m4/locale_h.m4:93: -1- AC_DEFUN([gl_LOCALE_T], [ - dnl Persuade glibc and Solaris to define locale_t. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - dnl Check whether use of locale_t requires inclusion of , - dnl e.g. on Mac OS X 10.5. If does not define locale_t by - dnl itself, we assume that will do so. - AC_CACHE_CHECK([whether locale.h defines locale_t], - [gl_cv_header_locale_has_locale_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - locale_t x;]], - [[]])], - [gl_cv_header_locale_has_locale_t=yes], - [gl_cv_header_locale_has_locale_t=no]) - ]) - - dnl Check for . - AC_CHECK_HEADERS_ONCE([xlocale.h]) - if test $ac_cv_header_xlocale_h = yes; then - HAVE_XLOCALE_H=1 - if test $gl_cv_header_locale_has_locale_t = yes; then - gl_cv_header_locale_h_needs_xlocale_h=no - else - gl_cv_header_locale_h_needs_xlocale_h=yes - fi - HAVE_LOCALE_T=1 - else - HAVE_XLOCALE_H=0 - gl_cv_header_locale_h_needs_xlocale_h=no - if test $gl_cv_header_locale_has_locale_t = yes; then - HAVE_LOCALE_T=1 - else - HAVE_LOCALE_T=0 - fi - fi - AC_SUBST([HAVE_XLOCALE_H]) -]) -m4trace:gnulib-m4/locale_h.m4:138: -1- AC_DEFUN([gl_LOCALE_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_LOCALE_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/locale_h.m4:150: -1- AC_DEFUN([gl_LOCALE_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_LOCALE_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALECONV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETLOCALE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETLOCALE_NULL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUPLOCALE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALENAME_UNSAFE]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_LOCALE_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_LOCALE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/locale_h.m4:163: -1- AC_DEFUN([gl_LOCALE_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_NEWLOCALE=1; AC_SUBST([HAVE_NEWLOCALE]) - HAVE_DUPLOCALE=1; AC_SUBST([HAVE_DUPLOCALE]) - HAVE_FREELOCALE=1; AC_SUBST([HAVE_FREELOCALE]) - REPLACE_LOCALECONV=0; AC_SUBST([REPLACE_LOCALECONV]) - REPLACE_SETLOCALE=0; AC_SUBST([REPLACE_SETLOCALE]) - REPLACE_NEWLOCALE=0; AC_SUBST([REPLACE_NEWLOCALE]) - REPLACE_DUPLOCALE=0; AC_SUBST([REPLACE_DUPLOCALE]) - REPLACE_FREELOCALE=0; AC_SUBST([REPLACE_FREELOCALE]) - REPLACE_STRUCT_LCONV=0; AC_SUBST([REPLACE_STRUCT_LCONV]) - LOCALENAME_ENHANCE_LOCALE_FUNCS=0; AC_SUBST([LOCALENAME_ENHANCE_LOCALE_FUNCS]) -]) -m4trace:gnulib-m4/localename.m4:7: -1- AC_DEFUN([gl_LOCALENAME_UNSAFE], [ - AC_REQUIRE([gl_LOCALE_H_DEFAULTS]) - AC_REQUIRE([gl_LOCALE_T]) - AC_REQUIRE([gt_LC_MESSAGES]) - AC_REQUIRE([gt_INTL_THREAD_LOCALE_NAME]) - AC_REQUIRE([gt_INTL_MACOSX]) - AC_CHECK_HEADERS_ONCE([langinfo.h]) - if test $HAVE_LOCALE_T = 1; then - gl_CHECK_FUNCS_ANDROID([newlocale], [[#include ]]) - gl_CHECK_FUNCS_ANDROID([duplocale], [[#include ]]) - gl_CHECK_FUNCS_ANDROID([freelocale], [[#include ]]) - gl_func_newlocale="$ac_cv_func_newlocale" - gl_func_duplocale="$ac_cv_func_duplocale" - gl_func_freelocale="$ac_cv_func_freelocale" - else - dnl In 2019, some versions of z/OS lack the locale_t type and have broken - dnl newlocale, duplocale, freelocale functions. - gl_cv_onwards_func_newlocale='future OS version' - gl_cv_onwards_func_duplocale='future OS version' - gl_cv_onwards_func_freelocale='future OS version' - gl_func_newlocale=no - gl_func_duplocale=no - gl_func_freelocale=no - fi - if test $gl_func_newlocale != yes; then - HAVE_NEWLOCALE=0 - case "$gl_cv_onwards_func_newlocale" in - future*) REPLACE_NEWLOCALE=1 ;; - esac - fi - if test $gl_func_duplocale != yes; then - HAVE_DUPLOCALE=0 - case "$gl_cv_onwards_func_duplocale" in - future*) REPLACE_DUPLOCALE=1 ;; - esac - fi - if test $gl_func_freelocale != yes; then - HAVE_FREELOCALE=0 - case "$gl_cv_onwards_func_freelocale" in - future*) REPLACE_FREELOCALE=1 ;; - esac - fi - if test $gt_localename_enhances_locale_funcs = yes; then - REPLACE_NEWLOCALE=1 - REPLACE_DUPLOCALE=1 - REPLACE_FREELOCALE=1 - fi -]) -m4trace:gnulib-m4/localename.m4:57: -1- AC_DEFUN([gl_LOCALENAME_UNSAFE_LIMITED], [ - AC_REQUIRE([gt_LC_MESSAGES]) - AC_REQUIRE([gt_INTL_THREAD_LOCALE_NAME]) -]) -m4trace:gnulib-m4/lock.m4:9: -1- AC_DEFUN([gl_LOCK], [ - AC_REQUIRE([gl_THREADLIB]) - if test "$gl_threads_api" = posix; then - # OSF/1 4.0 and Mac OS X 10.1 lack the pthread_rwlock_t type and the - # pthread_rwlock_* functions. - has_rwlock=false - AC_CHECK_TYPE([pthread_rwlock_t], - [has_rwlock=true - AC_DEFINE([HAVE_PTHREAD_RWLOCK], [1], - [Define if the POSIX multithreading library has read/write locks.])], - [], - [#include ]) - if $has_rwlock; then - gl_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER - fi - # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro. - AC_COMPILE_IFELSE([ - AC_LANG_PROGRAM( - [[#include ]], - [[ -#if __FreeBSD__ == 4 -error "No, in FreeBSD 4.0 recursive mutexes actually don't work." -#elif (defined __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ \ - && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1070) -error "No, in Mac OS X < 10.7 recursive mutexes actually don't work." -#else -int x = (int)PTHREAD_MUTEX_RECURSIVE; -return !x; -#endif - ]])], - [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], [1], - [Define if the defines PTHREAD_MUTEX_RECURSIVE.])]) - fi - gl_PREREQ_LOCK -]) -m4trace:gnulib-m4/lock.m4:47: -1- AC_DEFUN([gl_PREREQ_LOCK], [:]) -m4trace:gnulib-m4/lstat.m4:11: -1- AC_DEFUN([gl_FUNC_LSTAT], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_SYS_STAT_H_DEFAULTS]) - dnl If lstat does not exist, the replacement does - dnl "#define lstat stat", and lstat.c is a no-op. - AC_CHECK_FUNCS_ONCE([lstat]) - if test $ac_cv_func_lstat = yes; then - AC_REQUIRE([gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK]) - case $host_os,$gl_cv_func_lstat_dereferences_slashed_symlink in - darwin* | solaris* | *no) - REPLACE_LSTAT=1 - ;; - esac - else - HAVE_LSTAT=0 - fi -]) -m4trace:gnulib-m4/lstat.m4:31: -1- AC_DEFUN([gl_PREREQ_LSTAT], [:]) -m4trace:gnulib-m4/lstat.m4:33: -1- AC_DEFUN([gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK], [ - dnl We don't use AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK any more, because it - dnl is no longer maintained in Autoconf and because it invokes AC_LIBOBJ. - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether lstat correctly handles trailing slash], - [gl_cv_func_lstat_dereferences_slashed_symlink], - [rm -f conftest.sym conftest.file - echo >conftest.file - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [AC_INCLUDES_DEFAULT], - [[struct stat sbuf; - if (symlink ("conftest.file", "conftest.sym") != 0) - return 1; - /* Linux will dereference the symlink and fail, as required by - POSIX. That is better in the sense that it means we will not - have to compile and use the lstat wrapper. */ - return lstat ("conftest.sym/", &sbuf) == 0; - ]])], - [gl_cv_func_lstat_dereferences_slashed_symlink=yes], - [gl_cv_func_lstat_dereferences_slashed_symlink=no], - [case "$host_os" in - linux-* | linux) - # Guess yes on Linux systems. - gl_cv_func_lstat_dereferences_slashed_symlink="guessing yes" ;; - midipix*) - # Guess yes on systems that emulate the Linux system calls. - gl_cv_func_lstat_dereferences_slashed_symlink="guessing yes" ;; - *-gnu* | gnu*) - # Guess yes on glibc systems. - gl_cv_func_lstat_dereferences_slashed_symlink="guessing yes" ;; - mingw* | windows*) - # Guess no on native Windows. - gl_cv_func_lstat_dereferences_slashed_symlink="guessing no" ;; - *) - # If we don't know, obey --enable-cross-guesses. - gl_cv_func_lstat_dereferences_slashed_symlink="$gl_cross_guess_normal" ;; - esac - ]) - rm -f conftest.sym conftest.file - ]) - case "$gl_cv_func_lstat_dereferences_slashed_symlink" in - *yes) - AC_DEFINE_UNQUOTED([LSTAT_FOLLOWS_SLASHED_SYMLINK], [1], - [Define to 1 if 'lstat' dereferences a symlink specified - with a trailing slash.]) - ;; - esac -]) -m4trace:gnulib-m4/malloc.m4:9: -1- AC_DEFUN([_AC_FUNC_MALLOC_IF], [ - AC_REQUIRE([AC_CANONICAL_HOST])dnl for cross-compiles - AC_CACHE_CHECK([whether malloc (0) returns nonnull], - [ac_cv_func_malloc_0_nonnull], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[void *p = malloc (0); - void * volatile vp = p; - int result = !vp; - free (p); - return result;]]) - ], - [ac_cv_func_malloc_0_nonnull=yes], - [ac_cv_func_malloc_0_nonnull=no], - [case "$host_os" in - # Guess yes on platforms where we know the result. - *-gnu* | freebsd* | netbsd* | openbsd* | bitrig* \ - | gnu* | *-musl* | midipix* | midnightbsd* \ - | hpux* | solaris* | cygwin* | mingw* | windows* | msys* ) - ac_cv_func_malloc_0_nonnull="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) ac_cv_func_malloc_0_nonnull="$gl_cross_guess_normal" ;; - esac - ]) - ]) - AS_CASE([$ac_cv_func_malloc_0_nonnull], [*yes], [$1], [$2]) -]) -m4trace:gnulib-m4/malloc.m4:43: -1- AC_DEFUN([gl_FUNC_MALLOC_GNU], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) - REPLACE_MALLOC_FOR_MALLOC_GNU="$REPLACE_MALLOC_FOR_MALLOC_POSIX" - if test $REPLACE_MALLOC_FOR_MALLOC_GNU = 0; then - _AC_FUNC_MALLOC_IF([], [REPLACE_MALLOC_FOR_MALLOC_GNU=1]) - fi -]) -m4trace:gnulib-m4/malloc.m4:57: -1- AC_DEFUN([gl_FUNC_MALLOC_PTRDIFF], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_CHECK_MALLOC_PTRDIFF]) - test "$gl_cv_malloc_ptrdiff" = yes || REPLACE_MALLOC_FOR_MALLOC_POSIX=1 -]) -m4trace:gnulib-m4/malloc.m4:67: -1- AC_DEFUN([gl_CHECK_MALLOC_PTRDIFF], [ - AC_CACHE_CHECK([whether malloc is ptrdiff_t safe], - [gl_cv_malloc_ptrdiff], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[/* 64-bit ptrdiff_t is so wide that no practical platform - can exceed it. */ - #define WIDE_PTRDIFF (PTRDIFF_MAX >> 31 >> 31 != 0) - - /* On rare machines where size_t fits in ptrdiff_t there - is no problem. */ - #define NARROW_SIZE (SIZE_MAX <= PTRDIFF_MAX) - - /* glibc 2.30 and later malloc refuses to exceed ptrdiff_t - bounds even on 32-bit platforms. We don't know which - non-glibc systems are safe. */ - #define KNOWN_SAFE (2 < __GLIBC__ + (30 <= __GLIBC_MINOR__)) - - #if WIDE_PTRDIFF || NARROW_SIZE || KNOWN_SAFE - return 0; - #else - #error "malloc might not be ptrdiff_t safe" - syntax error - #endif - ]])], - [gl_cv_malloc_ptrdiff=yes], - [gl_cv_malloc_ptrdiff=no]) - ]) -]) -m4trace:gnulib-m4/malloc.m4:105: -1- AC_DEFUN([gl_FUNC_MALLOC_POSIX], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_MALLOC_PTRDIFF]) - AC_REQUIRE([gl_CHECK_MALLOC_POSIX]) - if test "$gl_cv_func_malloc_posix" = yes; then - AC_DEFINE([HAVE_MALLOC_POSIX], [1], - [Define if malloc, realloc, and calloc set errno on allocation failure.]) - else - REPLACE_MALLOC_FOR_MALLOC_POSIX=1 - fi -]) -m4trace:gnulib-m4/malloc.m4:120: -1- AC_DEFUN([gl_CHECK_MALLOC_POSIX], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether malloc, realloc, calloc set errno on failure], - [gl_cv_func_malloc_posix], - [ - dnl It is too dangerous to try to allocate a large amount of memory: - dnl some systems go to their knees when you do that. So assume that - dnl all Unix implementations of the function set errno on failure, - dnl except on those platforms where we have seen 'test-malloc-gnu', - dnl 'test-realloc-gnu', 'test-calloc-gnu' fail. - case "$host_os" in - mingw* | windows*) - gl_cv_func_malloc_posix=no ;; - irix* | solaris*) - dnl On IRIX 6.5, the three functions return NULL with errno unset - dnl when the argument is larger than PTRDIFF_MAX. - dnl On Solaris 11.3, the three functions return NULL with errno set - dnl to EAGAIN, not ENOMEM, when the argument is larger than - dnl PTRDIFF_MAX. - dnl Here is a test program: -m4_divert_push([KILL]) -#include -#include -#include -#define ptrdiff_t long -#ifndef PTRDIFF_MAX -# define PTRDIFF_MAX ((ptrdiff_t) ((1UL << (8 * sizeof (ptrdiff_t) - 1)) - 1)) -#endif - -int main () -{ - void *p; - - fprintf (stderr, "PTRDIFF_MAX = %lu\n", (unsigned long) PTRDIFF_MAX); - - errno = 0; - p = malloc ((unsigned long) PTRDIFF_MAX + 1); - fprintf (stderr, "p=%p errno=%d\n", p, errno); - - errno = 0; - p = calloc (PTRDIFF_MAX / 2 + 1, 2); - fprintf (stderr, "p=%p errno=%d\n", p, errno); - - errno = 0; - p = realloc (NULL, (unsigned long) PTRDIFF_MAX + 1); - fprintf (stderr, "p=%p errno=%d\n", p, errno); - - return 0; -} -m4_divert_pop([KILL]) - gl_cv_func_malloc_posix=no ;; - *) - gl_cv_func_malloc_posix=yes ;; - esac - ]) -]) -m4trace:gnulib-m4/malloca.m4:8: -1- AC_DEFUN([gl_MALLOCA], [ - dnl Use the autoconf tests for alloca(), but not the AC_SUBSTed variables - dnl @ALLOCA@ and @LTALLOCA@. - dnl gl_FUNC_ALLOCA dnl Already brought in by the module dependencies. - AC_REQUIRE([gl_EEMALLOC]) -]) -m4trace:gnulib-m4/manywarnings.m4:16: -1- AC_DEFUN([gl_MANYWARN_COMPLEMENT], [ - gl_warn_set= - set x $2; shift - for gl_warn_item - do - case " $3 " in - *" $gl_warn_item "*) - ;; - *) - AS_VAR_APPEND([gl_warn_set], [" $gl_warn_item"]) - ;; - esac - done - $1=$gl_warn_set -]) -m4trace:gnulib-m4/manywarnings.m4:40: -1- AC_DEFUN([gl_MANYWARN_ALL_GCC], [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) -m4trace:gnulib-m4/manywarnings.m4:44: -1- AC_DEFUN([gl_MANYWARN_ALL_GCC(C)], [ - AC_LANG_PUSH([C]) - - dnl First, check for some issues that only occur when combining multiple - dnl gcc warning categories. - AC_REQUIRE([AC_PROG_CC]) - AS_IF([test -n "$GCC"], [ - AC_CACHE_CHECK([whether -Wno-missing-field-initializers is needed], - [gl_cv_cc_nomfi_needed], - [gl_cv_cc_nomfi_needed=no - gl_saved_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -Wextra -Werror" - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[struct file_data { int desc, name; }; - struct cmp { struct file_data file[1]; }; - void f (struct cmp *r) - { - typedef struct { int a; int b; } s_t; - s_t s1 = { 0, }; - struct cmp cmp = { .file[0].desc = r->file[0].desc + s1.a }; - *r = cmp; - } - ]], - [[]])], - [], - [CFLAGS="$CFLAGS -Wno-missing-field-initializers" - AC_COMPILE_IFELSE([], - [gl_cv_cc_nomfi_needed=yes])]) - CFLAGS="$gl_saved_CFLAGS" - ]) - - dnl Next, check if -Werror -Wuninitialized is useful with the - dnl user's choice of $CFLAGS; some versions of gcc warn that it - dnl has no effect if -O is not also used - AC_CACHE_CHECK([whether -Wuninitialized is supported], - [gl_cv_cc_uninitialized_supported], - [gl_saved_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -Werror -Wuninitialized" - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[]], [[]])], - [gl_cv_cc_uninitialized_supported=yes], - [gl_cv_cc_uninitialized_supported=no]) - CFLAGS="$gl_saved_CFLAGS" - ]) - ]) - - # List all gcc warning categories. - # To compare this list to your installed GCC's, run this Bash command: - # - # comm -3 \ - # <((sed -n 's/^ *\(-[^ 0-9][^ ]*\).*/\1/p' manywarnings.m4; \ - # awk '/^[^#]/ {print $1}' ../build-aux/gcc-warning.spec) | sort) \ - # <(LC_ALL=C gcc --help=warnings | sed -n 's/^ \(-[^ ]*\) .*/\1/p' | sort) - - $1= - for gl_manywarn_item in -fanalyzer -fstrict-flex-arrays \ - -Wall \ - -Warith-conversion \ - -Wbad-function-cast \ - -Wcast-align=strict \ - -Wdate-time \ - -Wdisabled-optimization \ - -Wdouble-promotion \ - -Wduplicated-branches \ - -Wduplicated-cond \ - -Wextra \ - -Wformat-signedness \ - -Winit-self \ - -Winline \ - -Winvalid-pch \ - -Wlogical-op \ - -Wmissing-declarations \ - -Wmissing-include-dirs \ - -Wmissing-prototypes \ - -Wnested-externs \ - -Wnull-dereference \ - -Wold-style-definition \ - -Wopenmp-simd \ - -Woverlength-strings \ - -Wpacked \ - -Wpointer-arith \ - -Wshadow \ - -Wstack-protector \ - -Wstrict-flex-arrays \ - -Wstrict-overflow \ - -Wstrict-prototypes \ - -Wsuggest-attribute=cold \ - -Wsuggest-attribute=const \ - -Wsuggest-attribute=format \ - -Wsuggest-attribute=malloc \ - -Wsuggest-attribute=noreturn \ - -Wsuggest-attribute=pure \ - -Wsuggest-final-methods \ - -Wsuggest-final-types \ - -Wsync-nand \ - -Wsystem-headers \ - -Wtrampolines \ - -Wuninitialized \ - -Wunknown-pragmas \ - -Wunsafe-loop-optimizations \ - -Wunused-macros \ - -Wvariadic-macros \ - -Wvector-operation-performance \ - -Wvla \ - -Wwrite-strings \ - \ - ; do - AS_VAR_APPEND([$1], [" $gl_manywarn_item"]) - done - - # gcc --help=warnings outputs an unusual form for these options; list - # them here so that the above 'comm' command doesn't report a false match. - AS_VAR_APPEND([$1], [' -Warray-bounds=2']) - AS_VAR_APPEND([$1], [' -Wattribute-alias=2']) - AS_VAR_APPEND([$1], [' -Wbidi-chars=any,ucn']) - AS_VAR_APPEND([$1], [' -Wformat-overflow=2']) - AS_VAR_APPEND([$1], [' -Wformat=2']) - AS_VAR_APPEND([$1], [' -Wformat-truncation=2']) - AS_VAR_APPEND([$1], [' -Wimplicit-fallthrough=5']) - AS_VAR_APPEND([$1], [' -Wshift-overflow=2']) - AS_VAR_APPEND([$1], [' -Wuse-after-free=3']) - AS_VAR_APPEND([$1], [' -Wunused-const-variable=2']) - AS_VAR_APPEND([$1], [' -Wvla-larger-than=4031']) - - # These are needed for older GCC versions. - if test -n "$GCC" && gl_gcc_version=`($CC --version) 2>/dev/null`; then - case $gl_gcc_version in - 'gcc (GCC) '[[0-3]].* | \ - 'gcc (GCC) '4.[[0-7]].*) - AS_VAR_APPEND([$1], [' -fdiagnostics-show-option']) - AS_VAR_APPEND([$1], [' -funit-at-a-time']) - ;; - esac - case $gl_gcc_version in - 'gcc (GCC) '[[0-9]].*) - AS_VAR_APPEND([$1], [' -fno-common']) - ;; - esac - fi - - # Disable specific options as needed. - if test "$gl_cv_cc_nomfi_needed" = yes; then - AS_VAR_APPEND([$1], [' -Wno-missing-field-initializers']) - fi - - if test "$gl_cv_cc_uninitialized_supported" = no; then - AS_VAR_APPEND([$1], [' -Wno-uninitialized']) - fi - - # This warning have too many false alarms in GCC 11.2.1. - # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=101713 - AS_VAR_APPEND([$1], [' -Wno-analyzer-malloc-leak']) - - AC_LANG_POP([C]) -]) -m4trace:gnulib-m4/manywarnings.m4:203: -1- AC_DEFUN([gl_MANYWARN_ALL_GCC(C++)], [ - gl_MANYWARN_ALL_GCC_CXX_IMPL([$1]) -]) -m4trace:gnulib-m4/mbchar.m4:10: -1- AC_DEFUN([gl_MBCHAR], [ - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) -]) -m4trace:gnulib-m4/mbiter.m4:10: -1- AC_DEFUN([gl_MBITER], [ - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - : -]) -m4trace:gnulib-m4/mbrtoc32.m4:7: -1- AC_DEFUN([gl_FUNC_MBRTOC32], [ - AC_REQUIRE([gl_UCHAR_H_DEFAULTS]) - - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is - dnl determined. It describes how our overridden mbrtowc is implemented. - dnl We then implement mbrtoc32 accordingly. - AC_REQUIRE([gl_MBSTATE_T_BROKEN]) - - AC_REQUIRE([gl_TYPE_CHAR32_T]) - AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) - - AC_REQUIRE([gl_CHECK_FUNC_MBRTOC32]) - if test $gl_cv_func_mbrtoc32 = no; then - HAVE_MBRTOC32=0 - else - if test $GNULIBHEADERS_OVERRIDE_CHAR32_T = 1 || test $REPLACE_MBSTATE_T = 1; then - REPLACE_MBRTOC32=1 - else - gl_MBRTOC32_EMPTY_INPUT - gl_MBRTOC32_C_LOCALE - case "$gl_cv_func_mbrtoc32_empty_input" in - *yes) ;; - *) AC_DEFINE([MBRTOC32_EMPTY_INPUT_BUG], [1], - [Define if the mbrtoc32 function does not return (size_t) -2 for empty input.]) - REPLACE_MBRTOC32=1 - ;; - esac - case "$gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ" in - *yes) ;; - *) AC_DEFINE([MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ], [1], - [Define if the mbrtoc32 function may signal encoding errors in the C locale.]) - REPLACE_MBRTOC32=1 - ;; - esac - fi - if test $HAVE_WORKING_MBRTOC32 = 0; then - REPLACE_MBRTOC32=1 - fi - fi -]) -m4trace:gnulib-m4/mbrtoc32.m4:50: -1- AC_DEFUN([gl_CHECK_FUNC_MBRTOC32], [ - dnl Cf. gl_CHECK_FUNCS_ANDROID - AC_CHECK_DECL([mbrtoc32], , , - [[#ifdef __HAIKU__ - #include - #endif - #include - ]]) - if test $ac_cv_have_decl_mbrtoc32 = yes; then - dnl We can't use AC_CHECK_FUNC here, because mbrtoc32() is defined as a - dnl static inline function on Haiku 2020. - AC_CACHE_CHECK([for mbrtoc32], [gl_cv_func_mbrtoc32], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #ifdef __HAIKU__ - #include - #endif - #include - ]], - [[char32_t c; - return mbrtoc32 (&c, "", 1, NULL) == 0; - ]]) - ], - [gl_cv_func_mbrtoc32=yes], - [gl_cv_func_mbrtoc32=no]) - ]) - else - gl_cv_func_mbrtoc32=no - fi -]) -m4trace:gnulib-m4/mbrtoc32.m4:85: -1- AC_DEFUN([gl_MBRTOC32_EMPTY_INPUT], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtoc32 works on empty input], - [gl_cv_func_mbrtoc32_empty_input], - [ - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ - #ifdef __HAIKU__ - #include - #endif - #include - static char32_t wc; - static mbstate_t mbs; - int - main (void) - { - return mbrtoc32 (&wc, "", 0, &mbs) != (size_t) -2; - }]])], - [gl_cv_func_mbrtoc32_empty_input=yes], - [gl_cv_func_mbrtoc32_empty_input=no], - [case "$host_os" in - # Guess no on glibc systems. - *-gnu* | gnu*) gl_cv_func_mbrtoc32_empty_input="guessing no" ;; - # Guess no on Android. - linux*-android*) gl_cv_func_mbrtoc32_empty_input="guessing no" ;; - # Guess no on native Windows. - mingw* | windows*) gl_cv_func_mbrtoc32_empty_input="guessing no" ;; - *) gl_cv_func_mbrtoc32_empty_input="guessing yes" ;; - esac - ]) - ]) -]) -m4trace:gnulib-m4/mbrtoc32.m4:125: -1- AC_DEFUN([gl_MBRTOC32_C_LOCALE], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether the C locale is free of encoding errors], - [gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #ifdef __HAIKU__ - #include - #endif - #include - ]], [[ - int i; - char *locale = setlocale (LC_ALL, "C"); - if (! locale) - return 2; - for (i = CHAR_MIN; i <= CHAR_MAX; i++) - { - char c = i; - char32_t wc; - mbstate_t mbs = { 0, }; - size_t ss = mbrtoc32 (&wc, &c, 1, &mbs); - if (1 < ss) - return 3; - } - return 0; - ]])], - [gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ=yes], - [gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ=no], - [case "$host_os" in - # Guess yes on native Windows. - mingw* | windows*) gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ="guessing yes" ;; - *) gl_cv_func_mbrtoc32_C_locale_sans_EILSEQ="$gl_cross_guess_normal" ;; - esac - ]) - ]) -]) -m4trace:gnulib-m4/mbrtoc32.m4:168: -1- AC_DEFUN([gl_MBRTOC32_SANITYCHECK], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gl_TYPE_CHAR32_T]) - AC_REQUIRE([gl_CHECK_FUNC_MBRTOC32]) - AC_REQUIRE([gt_LOCALE_FR]) - AC_REQUIRE([gt_LOCALE_ZH_CN]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - if test $GNULIBHEADERS_OVERRIDE_CHAR32_T = 1 || test $gl_cv_func_mbrtoc32 = no; then - HAVE_WORKING_MBRTOC32=0 - else - AC_CACHE_CHECK([whether mbrtoc32 works as well as mbrtowc], - [gl_cv_func_mbrtoc32_sanitycheck], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on FreeBSD, Solaris, native Windows. - freebsd* | midnightbsd* | solaris* | mingw* | windows*) - gl_cv_func_mbrtoc32_sanitycheck="guessing no" - ;; - # Guess yes otherwise. - *) - gl_cv_func_mbrtoc32_sanitycheck="guessing yes" - ;; - esac -changequote([,])dnl - if test $LOCALE_FR != none || test $LOCALE_ZH_CN != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include -#ifdef __HAIKU__ - #include -#endif -#include -int main () -{ - int result = 0; - /* This fails on native Windows: - mbrtoc32 returns (size_t)-1. - mbrtowc returns 1 (correct). */ - if (strcmp ("$LOCALE_FR", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_FR") != NULL) - { - mbstate_t state; - wchar_t wc = (wchar_t) 0xBADFACE; - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\374", 1, &state) == 1) - { - char32_t c32 = (wchar_t) 0xBADFACE; - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtoc32 (&c32, "\374", 1, &state) != 1) - result |= 1; - } - } - /* This fails on FreeBSD 13.0 and Solaris 11.4: - mbrtoc32 returns (size_t)-2 or (size_t)-1. - mbrtowc returns 4 (correct). */ - if (strcmp ("$LOCALE_ZH_CN", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL) - { - mbstate_t state; - wchar_t wc = (wchar_t) 0xBADFACE; - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\224\071\375\067", 4, &state) == 4) - { - char32_t c32 = (wchar_t) 0xBADFACE; - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtoc32 (&c32, "\224\071\375\067", 4, &state) != 4) - result |= 2; - } - } - return result; -}]])], - [gl_cv_func_mbrtoc32_sanitycheck=yes], - [gl_cv_func_mbrtoc32_sanitycheck=no], - [:]) - fi - ]) - case "$gl_cv_func_mbrtoc32_sanitycheck" in - *yes) - HAVE_WORKING_MBRTOC32=1 - AC_DEFINE([HAVE_WORKING_MBRTOC32], [1], - [Define if the mbrtoc32 function basically works.]) - ;; - *) HAVE_WORKING_MBRTOC32=0 ;; - esac - fi - AC_SUBST([HAVE_WORKING_MBRTOC32]) -]) -m4trace:gnulib-m4/mbrtoc32.m4:264: -1- AC_DEFUN([gl_PREREQ_MBRTOC32], [ - : -]) -m4trace:gnulib-m4/mbrtowc.m4:8: -1- AC_DEFUN([gl_FUNC_MBRTOWC], [ - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) - AC_REQUIRE([gl_PTHREADLIB]) - AC_CHECK_HEADERS_ONCE([threads.h]) - - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - gl_MBSTATE_T_BROKEN - - AC_CHECK_FUNCS_ONCE([mbrtowc]) - if test $ac_cv_func_mbrtowc = no; then - HAVE_MBRTOWC=0 - AC_CHECK_DECLS([mbrtowc],,, [[ - #include - ]]) - if test $ac_cv_have_decl_mbrtowc = yes; then - dnl On Minix 3.1.8, the system's declares mbrtowc() although - dnl it does not have the function. Avoid a collision with gnulib's - dnl replacement. - REPLACE_MBRTOWC=1 - fi - else - if test $REPLACE_MBSTATE_T = 1; then - REPLACE_MBRTOWC=1 - else - gl_MBRTOWC_NULL_ARG1 - gl_MBRTOWC_NULL_ARG2 - gl_MBRTOWC_RETVAL - gl_MBRTOWC_NUL_RETVAL - gl_MBRTOWC_STORES_INCOMPLETE - gl_MBRTOWC_EMPTY_INPUT - gl_MBRTOWC_C_LOCALE - case "$gl_cv_func_mbrtowc_null_arg1" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_NULL_ARG1_BUG], [1], - [Define if the mbrtowc function has the NULL pwc argument bug.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_null_arg2" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_NULL_ARG2_BUG], [1], - [Define if the mbrtowc function has the NULL string argument bug.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_retval" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_RETVAL_BUG], [1], - [Define if the mbrtowc function returns a wrong return value.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_nul_retval" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_NUL_RETVAL_BUG], [1], - [Define if the mbrtowc function does not return 0 for a NUL character.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_stores_incomplete" in - *no) ;; - *) AC_DEFINE([MBRTOWC_STORES_INCOMPLETE_BUG], [1], - [Define if the mbrtowc function stores a wide character when reporting incomplete input.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_empty_input" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_EMPTY_INPUT_BUG], [1], - [Define if the mbrtowc function does not return (size_t) -2 - for empty input.]) - REPLACE_MBRTOWC=1 - ;; - esac - case "$gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" in - *yes) ;; - *) AC_DEFINE([MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ], [1], - [Define if the mbrtowc function may signal encoding errors in the C locale.]) - REPLACE_MBRTOWC=1 - ;; - esac - fi - fi - if test $REPLACE_MBSTATE_T = 1; then - case "$host_os" in - mingw* | windows*) - MBRTOWC_LIB= - ;; - *) - gl_WEAK_SYMBOLS - case "$gl_cv_have_weak" in - *yes) MBRTOWC_LIB= ;; - *) MBRTOWC_LIB="$LIBPTHREAD" ;; - esac - ;; - esac - else - MBRTOWC_LIB= - fi - dnl MBRTOWC_LIB is expected to be '-pthread' or '-lpthread' on AIX - dnl with gcc or xlc, and empty otherwise. - AC_SUBST([MBRTOWC_LIB]) - dnl For backward compatibility. - LIB_MBRTOWC="$MBRTOWC_LIB" - AC_SUBST([LIB_MBRTOWC]) -]) -m4trace:gnulib-m4/mbrtowc.m4:122: -1- AC_DEFUN_ONCE([gl_MBSTATE_T_BROKEN], [ - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - AC_CHECK_FUNCS_ONCE([mbsinit]) - AC_CHECK_FUNCS_ONCE([mbrtowc]) - dnl On native Windows, we know exactly how mbsinit() behaves and don't need - dnl to override it, even if - like on MSVC - mbsinit() is only defined as - dnl an inline function, not as a global function. - if case "$host_os" in - mingw* | windows*) true ;; - *) test $ac_cv_func_mbsinit = yes ;; - esac \ - && test $ac_cv_func_mbrtowc = yes; then - gl_MBRTOWC_INCOMPLETE_STATE - gl_MBRTOWC_SANITYCHECK - REPLACE_MBSTATE_T=0 - case "$gl_cv_func_mbrtowc_incomplete_state" in - *yes) ;; - *) REPLACE_MBSTATE_T=1 ;; - esac - case "$gl_cv_func_mbrtowc_sanitycheck" in - *yes) ;; - *) REPLACE_MBSTATE_T=1 ;; - esac - else - REPLACE_MBSTATE_T=1 - fi -]) -m4trace:gnulib-m4/mbrtowc.m4:158: -1- AC_DEFUN([gl_MBRTOWC_INCOMPLETE_STATE], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_JA]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc handles incomplete characters], - [gl_cv_func_mbrtowc_incomplete_state], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on AIX and OSF/1. - aix* | osf*) gl_cv_func_mbrtowc_incomplete_state="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_mbrtowc_incomplete_state="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_JA != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - if (setlocale (LC_ALL, "$LOCALE_JA") != NULL) - { - const char input[] = "B\217\253\344\217\251\316er"; /* "Büßer" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2)) - if (mbsinit (&state)) - return 2; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_incomplete_state=yes], - [gl_cv_func_mbrtowc_incomplete_state=no], - [:]) - else - if test $LOCALE_FR_UTF8 != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - const char input[] = "B\303\274\303\237er"; /* "Büßer" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2)) - if (mbsinit (&state)) - return 2; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_incomplete_state=yes], - [gl_cv_func_mbrtowc_incomplete_state=no], - [:]) - fi - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:234: -1- AC_DEFUN([gl_MBRTOWC_SANITYCHECK], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_ZH_CN]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc works as well as mbtowc], - [gl_cv_func_mbrtowc_sanitycheck], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on Solaris 8. - solaris2.8) gl_cv_func_mbrtowc_sanitycheck="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_mbrtowc_sanitycheck="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_ZH_CN != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include -int main () -{ - /* This fails on Solaris 8: - mbrtowc returns 2, and sets wc to 0x00F0. - mbtowc returns 4 (correct) and sets wc to 0x5EDC. */ - if (setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL) - { - char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 3, 6, &state) != 4 - && mbtowc (&wc, input + 3, 6) == 4) - return 2; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_sanitycheck=yes], - [gl_cv_func_mbrtowc_sanitycheck=no], - [:]) - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:287: -1- AC_DEFUN([gl_MBRTOWC_NULL_ARG1], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc handles a NULL pwc argument], - [gl_cv_func_mbrtowc_null_arg1], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on Solaris. - solaris*) gl_cv_func_mbrtowc_null_arg1="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_mbrtowc_null_arg1="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_FR_UTF8 != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include -int main () -{ - int result = 0; - - if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - char input[] = "\303\237er"; - mbstate_t state; - wchar_t wc; - size_t ret; - - memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; - ret = mbrtowc (&wc, input, 5, &state); - if (ret != 2) - result |= 1; - if (!mbsinit (&state)) - result |= 2; - - memset (&state, '\0', sizeof (mbstate_t)); - ret = mbrtowc (NULL, input, 5, &state); - if (ret != 2) /* Solaris 7 fails here: ret is -1. */ - result |= 4; - if (!mbsinit (&state)) - result |= 8; - } - return result; -}]])], - [gl_cv_func_mbrtowc_null_arg1=yes], - [gl_cv_func_mbrtowc_null_arg1=no], - [:]) - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:350: -1- AC_DEFUN([gl_MBRTOWC_NULL_ARG2], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc handles a NULL string argument], - [gl_cv_func_mbrtowc_null_arg2], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on OSF/1. - osf*) gl_cv_func_mbrtowc_null_arg2="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_mbrtowc_null_arg2="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_FR_UTF8 != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - mbstate_t state; - wchar_t wc; - int ret; - - memset (&state, '\0', sizeof (mbstate_t)); - wc = (wchar_t) 0xBADFACE; - mbrtowc (&wc, NULL, 5, &state); - /* Check that wc was not modified. */ - if (wc != (wchar_t) 0xBADFACE) - return 2; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_null_arg2=yes], - [gl_cv_func_mbrtowc_null_arg2=no], - [:]) - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:403: -1- AC_DEFUN([gl_MBRTOWC_RETVAL], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_REQUIRE([gt_LOCALE_JA]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether mbrtowc has a correct return value], - [gl_cv_func_mbrtowc_retval], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on HP-UX, Solaris, native Windows. - hpux* | solaris* | mingw* | windows*) - gl_cv_func_mbrtowc_retval="guessing no" ;; - # Guess yes otherwise. - *) - gl_cv_func_mbrtowc_retval="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_FR_UTF8 != none || test $LOCALE_JA != none \ - || { case "$host_os" in mingw* | windows*) true;; *) false;; esac; }; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - int result = 0; - int found_some_locale = 0; - /* This fails on Solaris. */ - if (strcmp ("$LOCALE_FR_UTF8", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - char input[] = "B\303\274\303\237er"; /* "Büßer" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2)) - { - input[1] = '\0'; - if (mbrtowc (&wc, input + 2, 5, &state) != 1) - result |= 1; - } - found_some_locale = 1; - } - /* This fails on HP-UX 11.11. */ - if (strcmp ("$LOCALE_JA", "none") != 0 - && setlocale (LC_ALL, "$LOCALE_JA") != NULL) - { - char input[] = "B\217\253\344\217\251\316er"; /* "Büßer" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2)) - { - input[1] = '\0'; - if (mbrtowc (&wc, input + 2, 5, &state) != 2) - result |= 2; - } - found_some_locale = 1; - } - /* This fails on native Windows. */ - if (setlocale (LC_ALL, "Japanese_Japan.932") != NULL) - { - char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2)) - { - input[3] = '\0'; - if (mbrtowc (&wc, input + 4, 4, &state) != 1) - result |= 4; - } - found_some_locale = 1; - } - if (setlocale (LC_ALL, "Chinese_Taiwan.950") != NULL) - { - char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2)) - { - input[3] = '\0'; - if (mbrtowc (&wc, input + 4, 4, &state) != 1) - result |= 8; - } - found_some_locale = 1; - } - if (setlocale (LC_ALL, "Chinese_China.936") != NULL) - { - char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */ - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2)) - { - input[3] = '\0'; - if (mbrtowc (&wc, input + 4, 4, &state) != 1) - result |= 16; - } - found_some_locale = 1; - } - return (found_some_locale ? result : 77); -}]])], - [gl_cv_func_mbrtowc_retval=yes], - [if test $? != 77; then - gl_cv_func_mbrtowc_retval=no - fi - ], - [:]) - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:530: -1- AC_DEFUN([gl_MBRTOWC_NUL_RETVAL], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([gt_LOCALE_ZH_CN]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc returns 0 when parsing a NUL character], - [gl_cv_func_mbrtowc_nul_retval], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on Solaris 8 and 9. - solaris2.[89]) gl_cv_func_mbrtowc_nul_retval="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_func_mbrtowc_nul_retval="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_ZH_CN != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - /* This fails on Solaris 8 and 9. */ - if (setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL) - { - mbstate_t state; - wchar_t wc; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "", 1, &state) != 0) - return 2; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_nul_retval=yes], - [gl_cv_func_mbrtowc_nul_retval=no], - [:]) - fi - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:578: -1- AC_DEFUN([gl_MBRTOWC_STORES_INCOMPLETE], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc stores incomplete characters], - [gl_cv_func_mbrtowc_stores_incomplete], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess yes on native Windows. - mingw* | windows*) gl_cv_func_mbrtowc_stores_incomplete="guessing yes" ;; - *) gl_cv_func_mbrtowc_stores_incomplete="guessing no" ;; - esac -changequote([,])dnl - case "$host_os" in - mingw* | windows*) - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - int result = 0; - if (setlocale (LC_ALL, "French_France.65001") != NULL) - { - wchar_t wc = (wchar_t) 0xBADFACE; - mbstate_t state; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2) - && wc != (wchar_t) 0xBADFACE) - result |= 1; - } - if (setlocale (LC_ALL, "Japanese_Japan.932") != NULL) - { - wchar_t wc = (wchar_t) 0xBADFACE; - mbstate_t state; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\226", 1, &state) == (size_t)(-2) - && wc != (wchar_t) 0xBADFACE) - result |= 2; - } - if (setlocale (LC_ALL, "Chinese_Taiwan.950") != NULL) - { - wchar_t wc = (wchar_t) 0xBADFACE; - mbstate_t state; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\245", 1, &state) == (size_t)(-2) - && wc != (wchar_t) 0xBADFACE) - result |= 4; - } - if (setlocale (LC_ALL, "Chinese_China.936") != NULL) - { - wchar_t wc = (wchar_t) 0xBADFACE; - mbstate_t state; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\261", 1, &state) == (size_t)(-2) - && wc != (wchar_t) 0xBADFACE) - result |= 8; - } - return result; -}]])], - [gl_cv_func_mbrtowc_stores_incomplete=no], - [gl_cv_func_mbrtowc_stores_incomplete=yes], - [:]) - ;; - *) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - if test $LOCALE_FR_UTF8 != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -int main () -{ - if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - wchar_t wc = (wchar_t) 0xBADFACE; - mbstate_t state; - - memset (&state, '\0', sizeof (mbstate_t)); - if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2) - && wc != (wchar_t) 0xBADFACE) - return 1; - } - return 0; -}]])], - [gl_cv_func_mbrtowc_stores_incomplete=no], - [gl_cv_func_mbrtowc_stores_incomplete=yes], - [:]) - fi - ;; - esac - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:683: -1- AC_DEFUN([gl_MBRTOWC_EMPTY_INPUT], [ - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether mbrtowc works on empty input], - [gl_cv_func_mbrtowc_empty_input], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ - #include - static wchar_t wc; - static mbstate_t mbs; - int - main (void) - { - return mbrtowc (&wc, "", 0, &mbs) != (size_t) -2; - }]])], - [gl_cv_func_mbrtowc_empty_input=yes], - [gl_cv_func_mbrtowc_empty_input=no], - [case "$host_os" in - # Guess no on AIX and glibc systems. - aix* | *-gnu* | gnu*) gl_cv_func_mbrtowc_empty_input="guessing no" ;; - # Guess no on Android. - linux*-android*) gl_cv_func_mbrtowc_empty_input="guessing no" ;; - # Guess no on native Windows. - mingw* | windows*) gl_cv_func_mbrtowc_empty_input="guessing no" ;; - *) gl_cv_func_mbrtowc_empty_input="guessing yes" ;; - esac - ]) - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:723: -1- AC_DEFUN([gl_MBRTOWC_C_LOCALE], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether the C locale is free of encoding errors], - [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #include - ]], [[ - int i; - char *locale = setlocale (LC_ALL, "C"); - if (! locale) - return 2; - for (i = CHAR_MIN; i <= CHAR_MAX; i++) - { - char c = i; - wchar_t wc; - mbstate_t mbs = { 0, }; - size_t ss = mbrtowc (&wc, &c, 1, &mbs); - if (1 < ss) - return 3; - } - return 0; - ]])], - [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ=yes], - [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ=no], - [case "$host_os" in - # Guess yes on native Windows. - mingw* | windows*) gl_cv_func_mbrtowc_C_locale_sans_EILSEQ="guessing yes" ;; - *) gl_cv_func_mbrtowc_C_locale_sans_EILSEQ="$gl_cross_guess_normal" ;; - esac - ]) - ]) -]) -m4trace:gnulib-m4/mbrtowc.m4:761: -1- AC_DEFUN([gl_PREREQ_MBRTOWC], [ - AC_REQUIRE([AC_C_INLINE]) - : -]) -m4trace:gnulib-m4/mbrtowc.m4:767: -1- AC_DEFUN([gl_PREREQ_MBTOWC_LOCK], [ - gl_VISIBILITY -]) -m4trace:gnulib-m4/mbrtowc.m4:777: -1- AC_DEFUN([AC_FUNC_MBRTOWC], [ - dnl Same as AC_FUNC_MBRTOWC in autoconf-2.60. - AC_CACHE_CHECK([whether mbrtowc and mbstate_t are properly declared], - [gl_cv_func_mbrtowc], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[wchar_t wc; - char const s[] = ""; - size_t n = 1; - mbstate_t state; - return ! (sizeof state && (mbrtowc) (&wc, s, n, &state));]])], - [gl_cv_func_mbrtowc=yes], - [gl_cv_func_mbrtowc=no])]) - if test $gl_cv_func_mbrtowc = yes; then - AC_DEFINE([HAVE_MBRTOWC], [1], - [Define to 1 if mbrtowc and mbstate_t are properly declared.]) - fi -]) -m4trace:gnulib-m4/mbsinit.m4:7: -1- AC_DEFUN([gl_FUNC_MBSINIT], [ - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - AC_REQUIRE([AC_TYPE_MBSTATE_T]) - gl_MBSTATE_T_BROKEN - - AC_CHECK_FUNCS_ONCE([mbsinit]) - if test $ac_cv_func_mbsinit = no; then - HAVE_MBSINIT=0 - AC_CHECK_DECLS([mbsinit],,, [[ - #include - ]]) - if test $ac_cv_have_decl_mbsinit = yes; then - dnl On Minix 3.1.8, the system's declares mbsinit() although - dnl it does not have the function. Avoid a collision with gnulib's - dnl replacement. - REPLACE_MBSINIT=1 - fi - else - if test $REPLACE_MBSTATE_T = 1; then - REPLACE_MBSINIT=1 - else - dnl On mingw, mbsinit() always returns 1, which is inappropriate for - dnl states produced by mbrtowc() for an incomplete multibyte character - dnl in multibyte locales. - case "$host_os" in - mingw* | windows*) REPLACE_MBSINIT=1 ;; - esac - fi - fi -]) -m4trace:gnulib-m4/mbsinit.m4:42: -1- AC_DEFUN([gl_PREREQ_MBSINIT], [ - : -]) -m4trace:gnulib-m4/mbslen.m4:7: -1- AC_DEFUN([gl_FUNC_MBSLEN], [ - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - AC_CHECK_FUNCS_ONCE([mbslen]) - if test $ac_cv_func_mbslen = yes; then - HAVE_MBSLEN=1 - else - HAVE_MBSLEN=0 - fi -]) -m4trace:gnulib-m4/mbstate_t.m4:15: -1- AC_DEFUN([AC_TYPE_MBSTATE_T], [ - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) dnl for HP-UX 11.11 - - AC_CACHE_CHECK([for mbstate_t], [ac_cv_type_mbstate_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [AC_INCLUDES_DEFAULT[ - #include ]], - [[mbstate_t x; return sizeof x;]])], - [ac_cv_type_mbstate_t=yes], - [ac_cv_type_mbstate_t=no])]) - if test $ac_cv_type_mbstate_t = yes; then - AC_DEFINE([HAVE_MBSTATE_T], [1], - [Define to 1 if declares mbstate_t.]) - else - AC_DEFINE([mbstate_t], [int], - [Define to a type if does not define.]) - fi -]) -m4trace:gnulib-m4/memchr.m4:7: -1- AC_DEFUN_ONCE([gl_FUNC_MEMCHR], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - dnl Check for prerequisites for memory fence checks. - gl_FUNC_MMAP_ANON - AC_CHECK_HEADERS_ONCE([sys/mman.h]) - AC_CHECK_FUNCS_ONCE([mprotect]) - - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - # Detect platform-specific bugs in some versions of glibc: - # memchr should not dereference anything with length 0 - # https://bugzilla.redhat.com/show_bug.cgi?id=499689 - # memchr should not dereference overestimated length after a match - # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=521737 - # https://sourceware.org/bugzilla/show_bug.cgi?id=10162 - # memchr should cast the second argument to 'unsigned char'. - # This bug exists in Android 4.3. - # Assume that memchr works on platforms that lack mprotect. - AC_CACHE_CHECK([whether memchr works], [gl_cv_func_memchr_works], - [AC_RUN_IFELSE([AC_LANG_PROGRAM([[ -#include -#if HAVE_SYS_MMAN_H -# include -# include -# include -# include -# ifndef MAP_FILE -# define MAP_FILE 0 -# endif -#endif -]], [[ - int result = 0; - char *fence = NULL; -#if HAVE_SYS_MMAN_H && HAVE_MPROTECT -# if HAVE_MAP_ANONYMOUS - const int flags = MAP_ANONYMOUS | MAP_PRIVATE; - const int fd = -1; -# else /* !HAVE_MAP_ANONYMOUS */ - const int flags = MAP_FILE | MAP_PRIVATE; - int fd = open ("/dev/zero", O_RDONLY, 0666); - if (fd >= 0) -# endif - { - int pagesize = getpagesize (); - char *two_pages = - (char *) mmap (NULL, 2 * pagesize, PROT_READ | PROT_WRITE, - flags, fd, 0); - if (two_pages != (char *)(-1) - && mprotect (two_pages + pagesize, pagesize, PROT_NONE) == 0) - fence = two_pages + pagesize; - } -#endif - if (fence) - { - /* Test against bugs on glibc systems. */ - if (memchr (fence, 0, 0)) - result |= 1; - strcpy (fence - 9, "12345678"); - if (memchr (fence - 9, 0, 79) != fence - 1) - result |= 2; - if (memchr (fence - 1, 0, 3) != fence - 1) - result |= 4; - /* Test against bug on AIX 7.2. */ - if (memchr (fence - 4, '6', 16) != fence - 4) - result |= 8; - } - /* Test against bug on Android 4.3. */ - { - char input[3]; - input[0] = 'a'; - input[1] = 'b'; - input[2] = 'c'; - if (memchr (input, 0x789abc00 | 'b', 3) != input + 1) - result |= 16; - } - return result; -]])], - [gl_cv_func_memchr_works=yes], - [gl_cv_func_memchr_works=no], - [case "$host_os" in - # Guess no on Android. - linux*-android*) gl_cv_func_memchr_works="guessing no" ;; - # Guess yes on native Windows. - mingw* | windows*) gl_cv_func_memchr_works="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_memchr_works="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_memchr_works" in - *yes) ;; - *) REPLACE_MEMCHR=1 ;; - esac -]) -m4trace:gnulib-m4/memchr.m4:104: -1- AC_DEFUN([gl_PREREQ_MEMCHR], [ - AC_CHECK_HEADERS([bp-sym.h]) -]) -m4trace:gnulib-m4/memmove.m4:7: -1- AC_DEFUN([gl_FUNC_MEMMOVE], [ - AC_CHECK_FUNCS([memmove]) -]) -m4trace:gnulib-m4/memmove.m4:13: -1- AC_DEFUN([gl_PREREQ_MEMMOVE], [ - : -]) -m4trace:gnulib-m4/mempcpy.m4:8: -1- AC_DEFUN([gl_FUNC_MEMPCPY], [ - dnl Persuade glibc to declare mempcpy(). - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - dnl The mempcpy() declaration in lib/string.in.h uses 'restrict'. - AC_REQUIRE([AC_C_RESTRICT]) - - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - gl_CHECK_FUNCS_ANDROID([mempcpy], [[#include ]]) - if test $ac_cv_func_mempcpy = no; then - HAVE_MEMPCPY=0 - case "$gl_cv_onwards_func_mempcpy" in - future*) REPLACE_MEMPCPY=1 ;; - esac - fi -]) -m4trace:gnulib-m4/mempcpy.m4:27: -1- AC_DEFUN([gl_PREREQ_MEMPCPY], [ - : -]) -m4trace:gnulib-m4/minmax.m4:9: -1- AC_DEFUN([gl_MINMAX], [ - AC_REQUIRE([gl_PREREQ_MINMAX]) -]) -m4trace:gnulib-m4/minmax.m4:15: -1- AC_DEFUN([gl_PREREQ_MINMAX], [ - gl_MINMAX_IN_HEADER([limits.h]) - gl_MINMAX_IN_HEADER([sys/param.h]) -]) -m4trace:gnulib-m4/minmax.m4:25: -1- AC_DEFUN([gl_MINMAX_IN_HEADER], [ - m4_pushdef([header], AS_TR_SH([$1])) - m4_pushdef([HEADER], AS_TR_CPP([$1])) - AC_CACHE_CHECK([whether <$1> defines MIN and MAX], - [gl_cv_minmax_in_]header, - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include <$1> - int x = MIN (42, 17);]], - [[]])], - [gl_cv_minmax_in_]header[=yes], - [gl_cv_minmax_in_]header[=no])]) - if test $gl_cv_minmax_in_[]header = yes; then - AC_DEFINE([HAVE_MINMAX_IN_]HEADER, 1, - [Define to 1 if <$1> defines the MIN and MAX macros.]) - fi - m4_popdef([HEADER]) - m4_popdef([header]) -]) -m4trace:gnulib-m4/mmap-anon.m4:16: -1- AC_DEFUN_ONCE([gl_FUNC_MMAP_ANON], [ - dnl Persuade glibc to define MAP_ANONYMOUS. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - # Check for mmap(). Don't use AC_FUNC_MMAP, because it checks too much: it - # fails on HP-UX 11, because MAP_FIXED mappings do not work. But this is - # irrelevant for anonymous mappings. - AC_CHECK_FUNC([mmap], [gl_have_mmap=yes], [gl_have_mmap=no]) - - # Try to allow MAP_ANONYMOUS. - gl_have_mmap_anonymous=no - if test $gl_have_mmap = yes; then - AC_MSG_CHECKING([for MAP_ANONYMOUS]) - AC_EGREP_CPP([I cannot identify this map], [ -#include -#ifdef MAP_ANONYMOUS - I cannot identify this map -#endif -], - [gl_have_mmap_anonymous=yes]) - if test $gl_have_mmap_anonymous != yes; then - AC_EGREP_CPP([I cannot identify this map], [ -#include -#ifdef MAP_ANON - I cannot identify this map -#endif -], - [AC_DEFINE([MAP_ANONYMOUS], [MAP_ANON], - [Define to a substitute value for mmap()'s MAP_ANONYMOUS flag.]) - gl_have_mmap_anonymous=yes]) - fi - AC_MSG_RESULT([$gl_have_mmap_anonymous]) - if test $gl_have_mmap_anonymous = yes; then - AC_DEFINE([HAVE_MAP_ANONYMOUS], [1], - [Define to 1 if mmap()'s MAP_ANONYMOUS flag is available after including - config.h and .]) - fi - fi -]) -m4trace:gnulib-m4/mode_t.m4:12: -1- AC_DEFUN([gl_PROMOTED_TYPE_MODE_T], [ - AC_REQUIRE([AC_TYPE_MODE_T]) - AC_CACHE_CHECK([for promoted mode_t type], [gl_cv_promoted_mode_t], [ - dnl Assume mode_t promotes to 'int' if and only if it is smaller than 'int', - dnl and to itself otherwise. This assumption is not guaranteed by the ISO C - dnl standard, but we don't know of any real-world counterexamples. - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], - [[typedef int array[2 * (sizeof (mode_t) < sizeof (int)) - 1];]])], - [gl_cv_promoted_mode_t='int'], - [gl_cv_promoted_mode_t='mode_t']) - ]) - AC_DEFINE_UNQUOTED([PROMOTED_MODE_T], [$gl_cv_promoted_mode_t], - [Define to the type that is the result of default argument promotions of type mode_t.]) -]) -m4trace:gnulib-m4/msvc-inval.m4:7: -1- AC_DEFUN([gl_MSVC_INVAL], [ - AC_CHECK_FUNCS_ONCE([_set_invalid_parameter_handler]) - if test $ac_cv_func__set_invalid_parameter_handler = yes; then - HAVE_MSVC_INVALID_PARAMETER_HANDLER=1 - AC_DEFINE([HAVE_MSVC_INVALID_PARAMETER_HANDLER], [1], - [Define to 1 on MSVC platforms that have the "invalid parameter handler" - concept.]) - else - HAVE_MSVC_INVALID_PARAMETER_HANDLER=0 - fi - AC_SUBST([HAVE_MSVC_INVALID_PARAMETER_HANDLER]) -]) -m4trace:gnulib-m4/msvc-nothrow.m4:7: -1- AC_DEFUN([gl_MSVC_NOTHROW], [ - AC_REQUIRE([gl_MSVC_INVAL]) -]) -m4trace:gnulib-m4/multiarch.m4:21: -1- AC_DEFUN_ONCE([gl_MULTIARCH], [ - dnl Code similar to autoconf-2.63 AC_C_BIGENDIAN. - AC_CACHE_CHECK([whether the compiler produces multi-arch binaries], - [gl_cv_c_multiarch], - [gl_cv_c_multiarch=no - AC_COMPILE_IFELSE( - [AC_LANG_SOURCE( - [[#ifndef __APPLE_CC__ - not a universal capable compiler - #endif - typedef int dummy; - ]])], - [ - dnl Check for potential -arch flags. It is not universal unless - dnl there are at least two -arch flags with different values. - arch= - prev= - for word in ${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS}; do - if test -n "$prev"; then - case $word in - i?86 | x86_64 | ppc | ppc64 | arm | arm64) - if test -z "$arch" || test "$arch" = "$word"; then - arch="$word" - else - gl_cv_c_multiarch=yes - fi - ;; - esac - prev= - else - if test "x$word" = "x-arch"; then - prev=arch - fi - fi - done - ]) - ]) - if test $gl_cv_c_multiarch = yes; then - APPLE_UNIVERSAL_BUILD=1 - else - APPLE_UNIVERSAL_BUILD=0 - fi - AC_SUBST([APPLE_UNIVERSAL_BUILD]) -]) -m4trace:gnulib-m4/musl.m4:12: -1- AC_DEFUN_ONCE([gl_MUSL_LIBC], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - *-musl* | midipix*) - AC_DEFINE([MUSL_LIBC], [1], [Define to 1 on musl libc.]) - ;; - esac -]) -m4trace:gnulib-m4/nocrash.m4:18: -1- AC_DEFUN([GL_NOCRASH], [[ -#include -#if defined __MACH__ && defined __APPLE__ -/* Avoid a crash on Mac OS X. */ -#include -#include -#include -#include -#include -#include -/* The exception port on which our thread listens. */ -static mach_port_t our_exception_port; -/* The main function of the thread listening for exceptions of type - EXC_BAD_ACCESS. */ -static void * -mach_exception_thread (void *arg) -{ - /* Buffer for a message to be received. */ - struct { - mach_msg_header_t head; - mach_msg_body_t msgh_body; - char data[1024]; - } msg; - mach_msg_return_t retval; - /* Wait for a message on the exception port. */ - retval = mach_msg (&msg.head, MACH_RCV_MSG | MACH_RCV_LARGE, 0, sizeof (msg), - our_exception_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); - if (retval != MACH_MSG_SUCCESS) - abort (); - exit (1); -} -static void -nocrash_init (void) -{ - mach_port_t self = mach_task_self (); - /* Allocate a port on which the thread shall listen for exceptions. */ - if (mach_port_allocate (self, MACH_PORT_RIGHT_RECEIVE, &our_exception_port) - == KERN_SUCCESS) { - /* See https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/mach_port_insert_right.html. */ - if (mach_port_insert_right (self, our_exception_port, our_exception_port, - MACH_MSG_TYPE_MAKE_SEND) - == KERN_SUCCESS) { - /* The exceptions we want to catch. Only EXC_BAD_ACCESS is interesting - for us. */ - exception_mask_t mask = EXC_MASK_BAD_ACCESS; - /* Create the thread listening on the exception port. */ - pthread_attr_t attr; - pthread_t thread; - if (pthread_attr_init (&attr) == 0 - && pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED) == 0 - && pthread_create (&thread, &attr, mach_exception_thread, NULL) == 0) { - pthread_attr_destroy (&attr); - /* Replace the exception port info for these exceptions with our own. - Note that we replace the exception port for the entire task, not only - for a particular thread. This has the effect that when our exception - port gets the message, the thread specific exception port has already - been asked, and we don't need to bother about it. - See https://web.mit.edu/darwin/src/modules/xnu/osfmk/man/task_set_exception_ports.html. */ - task_set_exception_ports (self, mask, our_exception_port, - EXCEPTION_DEFAULT, MACHINE_THREAD_STATE); - } - } - } -} -#elif defined _WIN32 && ! defined __CYGWIN__ -/* Avoid a crash on native Windows. */ -#define WIN32_LEAN_AND_MEAN -#include -#include -static LONG WINAPI -exception_filter (EXCEPTION_POINTERS *ExceptionInfo) -{ - switch (ExceptionInfo->ExceptionRecord->ExceptionCode) - { - case EXCEPTION_ACCESS_VIOLATION: - case EXCEPTION_IN_PAGE_ERROR: - case EXCEPTION_STACK_OVERFLOW: - case EXCEPTION_GUARD_PAGE: - case EXCEPTION_PRIV_INSTRUCTION: - case EXCEPTION_ILLEGAL_INSTRUCTION: - case EXCEPTION_DATATYPE_MISALIGNMENT: - case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: - case EXCEPTION_NONCONTINUABLE_EXCEPTION: - exit (1); - } - return EXCEPTION_CONTINUE_SEARCH; -} -static void -nocrash_init (void) -{ - SetUnhandledExceptionFilter ((LPTOP_LEVEL_EXCEPTION_FILTER) exception_filter); -} -#else -/* Avoid a crash on POSIX systems. */ -#include -#include -/* A POSIX signal handler. */ -static void -exception_handler (int sig) -{ - _exit (1); -} -static void -nocrash_init (void) -{ -#ifdef SIGSEGV - signal (SIGSEGV, exception_handler); -#endif -#ifdef SIGBUS - signal (SIGBUS, exception_handler); -#endif -} -#endif -]]) -m4trace:gnulib-m4/off_t.m4:10: -1- AC_DEFUN([gl_TYPE_OFF_T], [ - m4_ifdef([gl_LARGEFILE], [ - AC_REQUIRE([gl_LARGEFILE]) - ], [ - WINDOWS_64_BIT_OFF_T=0 - ]) - AC_SUBST([WINDOWS_64_BIT_OFF_T]) -]) -m4trace:gnulib-m4/open-cloexec.m4:8: -1- AC_DEFUN([gl_PREPROC_O_CLOEXEC], [ - AC_CACHE_CHECK([for O_CLOEXEC], - [gl_cv_macro_O_CLOEXEC], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include - #ifndef O_CLOEXEC - choke me; - #endif - ]], - [[return O_CLOEXEC;]])], - [gl_cv_macro_O_CLOEXEC=yes], - [gl_cv_macro_O_CLOEXEC=no])]) -]) -m4trace:gnulib-m4/open-slash.m4:9: -1- AC_DEFUN([gl_OPEN_TRAILING_SLASH_BUG], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - dnl open("foo/") should not create a file when the file name has a - dnl trailing slash. FreeBSD only has the problem on symlinks. - AC_CHECK_FUNCS_ONCE([lstat]) - AC_CACHE_CHECK([whether open recognizes a trailing slash], - [gl_cv_func_open_slash], - [# Assume that if we have lstat, we can also check symlinks. - if test $ac_cv_func_lstat = yes; then - touch conftest.tmp - ln -s conftest.tmp conftest.lnk - fi - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#if HAVE_UNISTD_H -# include -#endif -]GL_MDA_DEFINES[ -int main () -{ - int result = 0; -#if HAVE_LSTAT - if (open ("conftest.lnk/", O_RDONLY) != -1) - result |= 1; -#endif - if (open ("conftest.sl/", O_CREAT, 0600) >= 0) - result |= 2; - return result; -}]])], - [gl_cv_func_open_slash=yes], - [gl_cv_func_open_slash=no], - [ -changequote(,)dnl - case "$host_os" in - freebsd* | aix* | hpux* | solaris2.[0-9] | solaris2.[0-9].*) - gl_cv_func_open_slash="guessing no" ;; - *) - gl_cv_func_open_slash="guessing yes" ;; - esac -changequote([,])dnl - ]) - rm -f conftest.sl conftest.tmp conftest.lnk - ]) - case "$gl_cv_func_open_slash" in - *no) - AC_DEFINE([OPEN_TRAILING_SLASH_BUG], [1], - [Define to 1 if open() fails to recognize a trailing slash.]) - ;; - esac -]) -m4trace:gnulib-m4/open.m4:7: -1- AC_DEFUN([gl_FUNC_OPEN], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_PREPROC_O_CLOEXEC]) - case "$host_os" in - mingw* | windows* | pw*) - REPLACE_OPEN=1 - ;; - *) - dnl open("foo/") should not create a file when the file name has a - dnl trailing slash. FreeBSD only has the problem on symlinks. - AC_CHECK_FUNCS_ONCE([lstat]) - if test "$gl_cv_macro_O_CLOEXEC" != yes; then - REPLACE_OPEN=1 - fi - gl_OPEN_TRAILING_SLASH_BUG - case "$gl_cv_func_open_slash" in - *no) - REPLACE_OPEN=1 - ;; - esac - ;; - esac - dnl Replace open() for supporting the gnulib-defined fchdir() function, - dnl to keep fchdir's bookkeeping up-to-date. - m4_ifdef([gl_FUNC_FCHDIR], [ - if test $REPLACE_OPEN = 0; then - gl_TEST_FCHDIR - if test $HAVE_FCHDIR = 0; then - REPLACE_OPEN=1 - fi - fi - ]) - dnl Replace open() for supporting the gnulib-defined O_NONBLOCK flag. - m4_ifdef([gl_NONBLOCKING_IO], [ - if test $REPLACE_OPEN = 0; then - gl_NONBLOCKING_IO - if test $gl_cv_have_open_O_NONBLOCK != yes; then - REPLACE_OPEN=1 - fi - fi - ]) -]) -m4trace:gnulib-m4/open.m4:52: -1- AC_DEFUN([gl_PREREQ_OPEN], [ - AC_REQUIRE([gl_PROMOTED_TYPE_MODE_T]) - : -]) -m4trace:gnulib-m4/pathmax.m4:8: -1- AC_DEFUN([gl_PATHMAX], [ - dnl Prerequisites of lib/pathmax.h. - AC_CHECK_HEADERS_ONCE([sys/param.h]) -]) -m4trace:gnulib-m4/pathmax.m4:16: -1- AC_DEFUN([gl_PATHMAX_SNIPPET], [[ -/* Arrange to define PATH_MAX, like "pathmax.h" does. */ -#if HAVE_UNISTD_H -# include -#endif -#include -#if defined HAVE_SYS_PARAM_H && !defined PATH_MAX && !defined MAXPATHLEN -# include -#endif -#if !defined PATH_MAX && defined MAXPATHLEN -# define PATH_MAX MAXPATHLEN -#endif -#ifdef __hpux -# undef PATH_MAX -# define PATH_MAX 1024 -#endif -#if defined _WIN32 && ! defined __CYGWIN__ -# undef PATH_MAX -# define PATH_MAX 260 -#endif -]]) -m4trace:gnulib-m4/pathmax.m4:39: -1- AC_DEFUN([gl_PATHMAX_SNIPPET_PREREQ], [ - AC_CHECK_HEADERS_ONCE([unistd.h sys/param.h]) -]) -m4trace:gnulib-m4/pthread_rwlock_rdlock.m4:35: -1- AC_DEFUN([gl_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER], [ - AC_REQUIRE([gl_THREADLIB]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CACHE_CHECK([whether pthread_rwlock_rdlock prefers a writer to a reader], - [gl_cv_pthread_rwlock_rdlock_prefer_writer], - [saved_LIBS="$LIBS" - LIBS="$LIBS $LIBMULTITHREAD" - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#include -#include - -#define SUCCEED() exit (0) -#define FAILURE() exit (1) -#define UNEXPECTED(n) (exit (10 + (n))) - -/* The main thread creates the waiting writer and the requesting reader threads - in the default way; this guarantees that they have the same priority. - We can reuse the main thread as first reader thread. */ - -static pthread_rwlock_t lock; -static pthread_t reader1; -static pthread_t writer; -static pthread_t reader2; -static pthread_t timer; -/* Used to pass control from writer to reader2 and from reader2 to timer, - as in a relay race. - Passing control from one running thread to another running thread - is most likely faster than to create the second thread. */ -static pthread_mutex_t baton; - -static void * -timer_func (void *ignored) -{ - /* Step 13 (can be before or after step 12): - The timer thread takes the baton, then waits a moment to make sure - it can tell whether the second reader thread is blocked at step 12. */ - if (pthread_mutex_lock (&baton)) - UNEXPECTED (13); - usleep (100000); - /* By the time we get here, it's clear that the second reader thread is - blocked at step 12. This is the desired behaviour. */ - SUCCEED (); -} - -static void * -reader2_func (void *ignored) -{ - int err; - - /* Step 8 (can be before or after step 7): - The second reader thread takes the baton, then waits a moment to make sure - the writer thread has reached step 7. */ - if (pthread_mutex_lock (&baton)) - UNEXPECTED (8); - usleep (100000); - /* Step 9: The second reader thread requests the lock. */ - err = pthread_rwlock_tryrdlock (&lock); - if (err == 0) - FAILURE (); - else if (err != EBUSY) - UNEXPECTED (9); - /* Step 10: Launch a timer, to test whether the next call blocks. */ - if (pthread_create (&timer, NULL, timer_func, NULL)) - UNEXPECTED (10); - /* Step 11: Release the baton. */ - if (pthread_mutex_unlock (&baton)) - UNEXPECTED (11); - /* Step 12: The second reader thread requests the lock. */ - err = pthread_rwlock_rdlock (&lock); - if (err == 0) - FAILURE (); - else - UNEXPECTED (12); -} - -static void * -writer_func (void *ignored) -{ - /* Step 4: Take the baton, so that the second reader thread does not go ahead - too early. */ - if (pthread_mutex_lock (&baton)) - UNEXPECTED (4); - /* Step 5: Create the second reader thread. */ - if (pthread_create (&reader2, NULL, reader2_func, NULL)) - UNEXPECTED (5); - /* Step 6: Release the baton. */ - if (pthread_mutex_unlock (&baton)) - UNEXPECTED (6); - /* Step 7: The writer thread requests the lock. */ - if (pthread_rwlock_wrlock (&lock)) - UNEXPECTED (7); - return NULL; -} - -int -main () -{ - reader1 = pthread_self (); - - /* Step 1: The main thread initializes the lock and the baton. */ - if (pthread_rwlock_init (&lock, NULL)) - UNEXPECTED (1); - if (pthread_mutex_init (&baton, NULL)) - UNEXPECTED (1); - /* Step 2: The main thread acquires the lock as a reader. */ - if (pthread_rwlock_rdlock (&lock)) - UNEXPECTED (2); - /* Step 3: Create the writer thread. */ - if (pthread_create (&writer, NULL, writer_func, NULL)) - UNEXPECTED (3); - /* Job done. Go to sleep. */ - for (;;) - { - sleep (1); - } -} -]])], - [gl_cv_pthread_rwlock_rdlock_prefer_writer=yes], - [gl_cv_pthread_rwlock_rdlock_prefer_writer=no], - [case "$host_os" in - # Guess no on glibc systems. - *-gnu* | gnu*) gl_cv_pthread_rwlock_rdlock_prefer_writer="guessing no" ;; - # Guess no on musl systems. - *-musl* | midipix*) gl_cv_pthread_rwlock_rdlock_prefer_writer="guessing no" ;; - # Guess no on bionic systems. - *-android*) gl_cv_pthread_rwlock_rdlock_prefer_writer="guessing no" ;; - # Guess yes on native Windows with the mingw-w64 winpthreads library. - # Guess no on native Windows with the gnulib windows-rwlock module. - mingw* | windows*) if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then - gl_cv_pthread_rwlock_rdlock_prefer_writer="guessing yes" - else - gl_cv_pthread_rwlock_rdlock_prefer_writer="guessing no" - fi - ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_pthread_rwlock_rdlock_prefer_writer="$gl_cross_guess_normal" ;; - esac - ]) - LIBS="$saved_LIBS" - ]) - case "$gl_cv_pthread_rwlock_rdlock_prefer_writer" in - *yes) - AC_DEFINE([HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER], [1], - [Define if the 'pthread_rwlock_rdlock' function prefers a writer to a reader.]) - ;; - esac -]) -m4trace:gnulib-m4/raise.m4:7: -1- AC_DEFUN([gl_FUNC_RAISE], [ - AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CHECK_FUNCS([raise]) - if test $ac_cv_func_raise = no; then - HAVE_RAISE=0 - else - m4_ifdef([gl_MSVC_INVAL], [ - AC_REQUIRE([gl_MSVC_INVAL]) - if test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1; then - REPLACE_RAISE=1 - fi - ]) - m4_ifdef([gl_SIGNALBLOCKING], [ - gl_SIGNALBLOCKING - if test $HAVE_POSIX_SIGNALBLOCKING = 0; then - m4_ifdef([gl_SIGNAL_SIGPIPE], [ - gl_SIGNAL_SIGPIPE - if test $gl_cv_header_signal_h_SIGPIPE != yes; then - REPLACE_RAISE=1 - fi - ], [:]) - fi - ]) - fi -]) -m4trace:gnulib-m4/raise.m4:36: -1- AC_DEFUN([gl_PREREQ_RAISE], [:]) -m4trace:gnulib-m4/rawmemchr.m4:7: -1- AC_DEFUN([gl_FUNC_RAWMEMCHR], [ - dnl Persuade glibc to declare rawmemchr(). - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - AC_CHECK_FUNCS([rawmemchr]) - if test $ac_cv_func_rawmemchr = no; then - HAVE_RAWMEMCHR=0 - fi -]) -m4trace:gnulib-m4/rawmemchr.m4:20: -1- AC_DEFUN([gl_PREREQ_RAWMEMCHR], [:]) -m4trace:gnulib-m4/readlink.m4:7: -1- AC_DEFUN([gl_FUNC_READLINK], [ - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CHECK_FUNCS_ONCE([readlink]) - if test $ac_cv_func_readlink = no; then - HAVE_READLINK=0 - else - AC_CACHE_CHECK([whether readlink signature is correct], - [gl_cv_decl_readlink_works], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - /* Cause compilation failure if original declaration has wrong type. */ - ssize_t readlink (const char *, char *, size_t);]])], - [gl_cv_decl_readlink_works=yes], [gl_cv_decl_readlink_works=no])]) - dnl Solaris 9 ignores trailing slash. - dnl FreeBSD 7.2 dereferences only one level of links with trailing slash. - AC_CACHE_CHECK([whether readlink handles trailing slash correctly], - [gl_cv_func_readlink_trailing_slash], - [# We have readlink, so assume ln -s works. - ln -s conftest.no-such conftest.link - ln -s conftest.link conftest.lnk2 - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include -]], [[char buf[20]; - return readlink ("conftest.lnk2/", buf, sizeof buf) != -1;]])], - [gl_cv_func_readlink_trailing_slash=yes], - [gl_cv_func_readlink_trailing_slash=no], - [case "$host_os" in - # Guess yes on Linux or glibc systems. - linux-* | linux | *-gnu* | gnu*) - gl_cv_func_readlink_trailing_slash="guessing yes" ;; - # Guess yes on systems that emulate the Linux system calls. - midipix*) - gl_cv_func_readlink_trailing_slash="guessing yes" ;; - # Guess no on AIX or HP-UX. - aix* | hpux*) - gl_cv_func_readlink_trailing_slash="guessing no" ;; - # If we don't know, obey --enable-cross-guesses. - *) - gl_cv_func_readlink_trailing_slash="$gl_cross_guess_normal" ;; - esac - ]) - rm -f conftest.link conftest.lnk2]) - case "$gl_cv_func_readlink_trailing_slash" in - *yes) - if test "$gl_cv_decl_readlink_works" != yes; then - REPLACE_READLINK=1 - fi - ;; - *) - AC_DEFINE([READLINK_TRAILING_SLASH_BUG], [1], [Define to 1 if readlink - fails to recognize a trailing slash.]) - REPLACE_READLINK=1 - ;; - esac - - AC_CACHE_CHECK([whether readlink truncates results correctly], - [gl_cv_func_readlink_truncate], - [# We have readlink, so assume ln -s works. - ln -s ab conftest.link - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include -]], [[char c; - return readlink ("conftest.link", &c, 1) != 1;]])], - [gl_cv_func_readlink_truncate=yes], - [gl_cv_func_readlink_truncate=no], - [case "$host_os" in - # Guess yes on Linux or glibc systems. - linux-* | linux | *-gnu* | gnu*) - gl_cv_func_readlink_truncate="guessing yes" ;; - # Guess yes on systems that emulate the Linux system calls. - midipix*) - gl_cv_func_readlink_truncate="guessing yes" ;; - # Guess no on AIX or HP-UX. - aix* | hpux*) - gl_cv_func_readlink_truncate="guessing no" ;; - # If we don't know, obey --enable-cross-guesses. - *) - gl_cv_func_readlink_truncate="$gl_cross_guess_normal" ;; - esac - ]) - rm -f conftest.link conftest.lnk2]) - case $gl_cv_func_readlink_truncate in - *yes) - if test "$gl_cv_decl_readlink_works" != yes; then - REPLACE_READLINK=1 - fi - ;; - *) - AC_DEFINE([READLINK_TRUNCATE_BUG], [1], [Define to 1 if readlink - sets errno instead of truncating a too-long link.]) - REPLACE_READLINK=1 - ;; - esac - fi -]) -m4trace:gnulib-m4/readlink.m4:110: -1- AC_DEFUN([gl_FUNC_READLINK_SEPARATE], [ - AC_CHECK_FUNCS_ONCE([readlink]) - gl_PREREQ_READLINK -]) -m4trace:gnulib-m4/readlink.m4:117: -1- AC_DEFUN([gl_PREREQ_READLINK], [ - : -]) -m4trace:gnulib-m4/realloc.m4:9: -1- AC_DEFUN([_AC_FUNC_REALLOC_IF], [ - AC_REQUIRE([AC_CANONICAL_HOST])dnl for cross-compiles - AC_CACHE_CHECK([whether realloc (0, 0) returns nonnull], - [ac_cv_func_realloc_0_nonnull], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[void *p = realloc (0, 0); - void * volatile vp = p; - int result = !vp; - free (p); - return result;]]) - ], - [ac_cv_func_realloc_0_nonnull=yes], - [ac_cv_func_realloc_0_nonnull=no], - [case "$host_os" in - # Guess yes on platforms where we know the result. - *-gnu* | freebsd* | netbsd* | openbsd* | bitrig* \ - | gnu* | *-musl* | midipix* | midnightbsd* \ - | hpux* | solaris* | cygwin* | mingw* | windows* | msys* ) - ac_cv_func_realloc_0_nonnull="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) ac_cv_func_realloc_0_nonnull="$gl_cross_guess_normal" ;; - esac - ]) - ]) - AS_CASE([$ac_cv_func_realloc_0_nonnull], [*yes], [$1], [$2]) -]) -m4trace:gnulib-m4/realloc.m4:43: -1- AC_DEFUN([gl_FUNC_REALLOC_GNU], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_REALLOC_POSIX]) - if test $REPLACE_REALLOC_FOR_REALLOC_GNU = 0; then - _AC_FUNC_REALLOC_IF([], [REPLACE_REALLOC_FOR_REALLOC_GNU=1]) - fi -]) -m4trace:gnulib-m4/realloc.m4:57: -1- AC_DEFUN([gl_FUNC_REALLOC_POSIX], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) - if test $REPLACE_MALLOC_FOR_MALLOC_POSIX = 1; then - REPLACE_REALLOC_FOR_REALLOC_POSIX=1 - fi -]) -m4trace:gnulib-m4/reallocarray.m4:7: -1- AC_DEFUN([gl_FUNC_REALLOCARRAY], [ - dnl Persuade glibc to declare reallocarray. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([gl_CHECK_MALLOC_PTRDIFF]) - gl_CHECK_FUNCS_ANDROID([reallocarray], [[#include ]]) - if test "$ac_cv_func_reallocarray" = no; then - HAVE_REALLOCARRAY=0 - case "$gl_cv_onwards_func_reallocarray" in - future*) REPLACE_REALLOCARRAY=1 ;; - esac - elif test "$gl_cv_malloc_ptrdiff" = no; then - REPLACE_REALLOCARRAY=1 - fi -]) -m4trace:gnulib-m4/reallocarray.m4:26: -1- AC_DEFUN([gl_PREREQ_REALLOCARRAY], [:]) -m4trace:gnulib-m4/relocatable-lib.m4:10: -1- AC_DEFUN([gl_RELOCATABLE_LIBRARY], [ - AC_REQUIRE([gl_RELOCATABLE_LIBRARY_BODY]) -]) -m4trace:gnulib-m4/relocatable-lib.m4:14: -1- AC_DEFUN([gl_RELOCATABLE_LIBRARY_BODY], [ - AC_REQUIRE([gl_RELOCATABLE_NOP]) - dnl Easier to put this here once, instead of into the DEFS of each Makefile. - if test "X$prefix" = "XNONE"; then - reloc_final_prefix="$ac_default_prefix" - else - reloc_final_prefix="$prefix" - fi - AC_DEFINE_UNQUOTED([INSTALLPREFIX], ["${reloc_final_prefix}"], - [Define to the value of ${prefix}, as a string.]) - if test $RELOCATABLE = yes; then - AC_DEFINE([ENABLE_RELOCATABLE], [1], - [Define to 1 if the package shall run at any location in the file - system.]) - fi -]) -m4trace:gnulib-m4/relocatable-lib.m4:33: -1- AC_DEFUN([gl_RELOCATABLE_NOP], [ - AC_MSG_CHECKING([whether to activate relocatable installation]) - AC_ARG_ENABLE([relocatable], - [AS_HELP_STRING([[--enable-relocatable]], - [install a package that can be moved in the file system])], - [if test "$enableval" != no; then - RELOCATABLE=yes - else - RELOCATABLE=no - fi - ], RELOCATABLE=no) - AC_SUBST([RELOCATABLE]) - AC_MSG_RESULT([$RELOCATABLE]) -]) -m4trace:gnulib-m4/relocatable.m4:13: -1- AC_DEFUN([gl_RELOCATABLE], [ - AC_REQUIRE([gl_RELOCATABLE_BODY]) - gl_RELOCATABLE_LIBRARY - : ${RELOCATABLE_CONFIG_H_DIR='$(top_builddir)'} - RELOCATABLE_SRC_DIR="\$(top_srcdir)/$gl_source_base" - RELOCATABLE_BUILD_DIR="\$(top_builddir)/$gl_source_base" -]) -m4trace:gnulib-m4/relocatable.m4:22: -1- AC_DEFUN([gl_RELOCATABLE_BODY], [ - AC_REQUIRE([AC_PROG_INSTALL]) - - dnl This AC_BEFORE invocation leads to unjustified autoconf warnings - dnl when gl_RELOCATABLE_BODY is invoked more than once. - dnl - dnl We need this AC_BEFORE because AC_PROG_INSTALL is documented to - dnl overwrite earlier settings of INSTALL and INSTALL_PROGRAM (even - dnl though in autoconf-2.52..2.60 it doesn't do so), but we want this - dnl macro's setting of INSTALL_PROGRAM to persist. - dnl Arghh: AC_BEFORE does not work in this setting :-( - dnl AC_BEFORE([AC_PROG_INSTALL],[gl_RELOCATABLE_BODY]) - dnl - dnl LT_INIT sets LIBTOOL, but we want this macro's setting of LIBTOOL to - dnl persist. - dnl Arghh: AC_BEFORE does not work in this setting :-( - dnl AC_BEFORE([LT_INIT],[gl_RELOCATABLE_BODY]) - - AC_REQUIRE([AC_LIB_LIBPATH]) - AC_REQUIRE([gl_RELOCATABLE_LIBRARY_BODY]) - AC_REQUIRE([AC_CANONICAL_HOST]) - is_noop=no - use_elf_origin_trick=no - use_macos_tools=no - use_wrapper=no - if test $RELOCATABLE = yes; then - # --enable-relocatable implies --disable-rpath - enable_rpath=no - AC_CHECK_HEADERS([mach-o/dyld.h]) - AC_CHECK_FUNCS([_NSGetExecutablePath]) - case "$host_os" in - mingw* | windows*) is_noop=yes ;; - # For the platforms that support $ORIGIN, see - # . - # glibc systems, Linux with musl libc: yes. Android: no. - linux*-android*) ;; - linux* | kfreebsd*) use_elf_origin_trick=yes ;; - # Hurd: - # only after the glibc commit from 2018-01-08 - # - gnu*) - # Test for a glibc version >= 2.27. - AC_CHECK_FUNCS([copy_file_range]) - if test $ac_cv_func_copy_file_range = yes; then - use_elf_origin_trick=yes - fi - ;; -changequote(,)dnl - # FreeBSD >= 7.3, DragonFly >= 3.0, MidnightBSD >= 1.1: yes. - freebsd | freebsd[1-7] | freebsd[1-6].* | freebsd7.[0-2]) ;; - dragonfly | dragonfly[1-2] | dragonfly[1-2].*) ;; - midnightbsd | midnightbsd0* | midnightbsd1.0*) ;; - freebsd* | dragonfly* | midnightbsd*) use_elf_origin_trick=yes ;; - # NetBSD >= 8.0: yes. - netbsd | netbsd[1-7] | netbsd[1-7].*) ;; - netbsdelf | netbsdelf[1-7] | netbsdelf[1-7].*) ;; - netbsd*) use_elf_origin_trick=yes ;; - # OpenBSD >= 5.4: yes. - openbsd | openbsd[1-5] | openbsd[1-4].* | openbsd5.[0-3]) ;; - openbsd*) use_elf_origin_trick=yes ;; - # Solaris >= 10: yes. - solaris | solaris2.[1-9] | solaris2.[1-9].*) ;; - solaris*) use_elf_origin_trick=yes ;; - # Haiku: yes. - haiku*) use_elf_origin_trick=yes ;; - # On Mac OS X 10.4 or newer, use Mac OS X tools. See - # . - darwin | darwin[1-7].*) ;; - darwin*) use_macos_tools=yes ;; -changequote([,])dnl - esac - if test $is_noop = yes; then - RELOCATABLE_LDFLAGS=: - AC_SUBST([RELOCATABLE_LDFLAGS]) - else - if test $use_elf_origin_trick = yes || test $use_macos_tools = yes; then - dnl Use the dynamic linker's support for relocatable programs. - case "$ac_aux_dir" in - /*) reloc_ldflags="$ac_aux_dir/reloc-ldflags" ;; - *) reloc_ldflags="\$(top_builddir)/$ac_aux_dir/reloc-ldflags" ;; - esac - RELOCATABLE_LDFLAGS="\"$reloc_ldflags\" \"\$(host)\" \"\$(RELOCATABLE_LIBRARY_PATH)\"" - AC_SUBST([RELOCATABLE_LDFLAGS]) - if test $use_macos_tools = yes; then - dnl Use a libtool wrapper that uses Mac OS X tools. - case "$ac_aux_dir" in - /*) LIBTOOL="${CONFIG_SHELL-$SHELL} $ac_aux_dir/libtool-reloc $LIBTOOL" ;; - *) LIBTOOL="${CONFIG_SHELL-$SHELL} \$(top_builddir)/$ac_aux_dir/libtool-reloc $LIBTOOL" ;; - esac - fi - else - use_wrapper=yes - dnl Unfortunately we cannot define INSTALL_PROGRAM to a command - dnl consisting of more than one word - libtool doesn't support this. - dnl So we abuse the INSTALL_PROGRAM_ENV hook, originally meant for the - dnl 'install-strip' target. - INSTALL_PROGRAM_ENV="RELOC_LIBRARY_PATH_VAR=\"$shlibpath_var\" RELOC_LIBRARY_PATH_VALUE=\"\$(RELOCATABLE_LIBRARY_PATH)\" RELOC_PREFIX=\"\$(prefix)\" RELOC_DESTDIR=\"\$(DESTDIR)\" RELOC_COMPILE_COMMAND=\"\$(CC) \$(CPPFLAGS) \$(CFLAGS) \$(LDFLAGS)\" RELOC_SRCDIR=\"\$(RELOCATABLE_SRC_DIR)\" RELOC_BUILDDIR=\"\$(RELOCATABLE_BUILD_DIR)\" RELOC_CONFIG_H_DIR=\"\$(RELOCATABLE_CONFIG_H_DIR)\" RELOC_EXEEXT=\"\$(EXEEXT)\" RELOC_STRIP_PROG=\"\$(RELOCATABLE_STRIP)\" RELOC_INSTALL_PROG=\"$INSTALL_PROGRAM\"" - AC_SUBST([INSTALL_PROGRAM_ENV]) - case "$ac_aux_dir" in - /*) INSTALL_PROGRAM="$ac_aux_dir/install-reloc" ;; - *) INSTALL_PROGRAM="\$(top_builddir)/$ac_aux_dir/install-reloc" ;; - esac - fi - fi - fi - AM_CONDITIONAL([RELOCATABLE_VIA_LD], - [test $is_noop = yes || test $use_elf_origin_trick = yes || test $use_macos_tools = yes]) - AM_CONDITIONAL([RELOCATABLE_VIA_WRAPPER], [test $use_wrapper = yes]) - - dnl RELOCATABLE_LIBRARY_PATH can be set in configure.ac. Default is empty. - AC_SUBST([RELOCATABLE_LIBRARY_PATH]) - - AC_SUBST([RELOCATABLE_CONFIG_H_DIR]) - AC_SUBST([RELOCATABLE_SRC_DIR]) - AC_SUBST([RELOCATABLE_BUILD_DIR]) - - dnl Ensure RELOCATABLE_STRIP is defined in Makefiles (at least those - dnl generated by automake), with value ':'. - RELOCATABLE_STRIP=':' - AC_SUBST([RELOCATABLE_STRIP]) -]) -m4trace:gnulib-m4/relocatable.m4:147: -1- AC_DEFUN([AC_LIB_LIBPATH], [ - AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD - AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host - AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir - AC_CACHE_CHECK([for shared library path variable], [acl_cv_libpath], [ - LD="$LD" \ - ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.libpath" "$host" > conftest.sh - . ./conftest.sh - rm -f ./conftest.sh - acl_cv_libpath=${acl_cv_shlibpath_var:-none} - ]) - shlibpath_var="$acl_cv_shlibpath_var" -]) -m4trace:gnulib-m4/setenv.m4:7: -1- AC_DEFUN([gl_FUNC_SETENV], [ - AC_REQUIRE([gl_FUNC_SETENV_SEPARATE]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - if test $ac_cv_func_setenv = no; then - HAVE_SETENV=0 - else - AC_CACHE_CHECK([whether setenv validates arguments], - [gl_cv_func_setenv_works], - [AC_RUN_IFELSE([AC_LANG_PROGRAM([[ - #include - #include - #include - ]], [[ - int result = 0; - { - if (setenv ("", "", 0) != -1) - result |= 1; - else if (errno != EINVAL) - result |= 2; - } - { - if (setenv ("a", "=", 1) != 0) - result |= 4; - else if (strcmp (getenv ("a"), "=") != 0) - result |= 8; - } - return result; - ]])], - [gl_cv_func_setenv_works=yes], [gl_cv_func_setenv_works=no], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_setenv_works="guessing yes" ;; - # Guess yes on musl systems. - *-musl* | midipix*) gl_cv_func_setenv_works="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_setenv_works="$gl_cross_guess_normal" ;; - esac - ])]) - case "$gl_cv_func_setenv_works" in - *yes) ;; - *) - REPLACE_SETENV=1 - ;; - esac - fi -]) -m4trace:gnulib-m4/setenv.m4:57: -1- AC_DEFUN([gl_FUNC_SETENV_SEPARATE], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_CHECK_DECLS_ONCE([setenv]) - if test $ac_cv_have_decl_setenv = no; then - HAVE_DECL_SETENV=0 - fi - AC_CHECK_FUNCS_ONCE([setenv]) - gl_PREREQ_SETENV -]) -m4trace:gnulib-m4/setenv.m4:68: -1- AC_DEFUN([gl_FUNC_UNSETENV], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CHECK_DECLS_ONCE([unsetenv]) - if test $ac_cv_have_decl_unsetenv = no; then - HAVE_DECL_UNSETENV=0 - fi - AC_CHECK_FUNCS([unsetenv]) - if test $ac_cv_func_unsetenv = no; then - HAVE_UNSETENV=0 - else - HAVE_UNSETENV=1 - dnl Some BSDs return void, failing to do error checking. - AC_CACHE_CHECK([for unsetenv() return type], [gt_cv_func_unsetenv_ret], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[ -#undef _BSD -#define _BSD 1 /* unhide unsetenv declaration in OSF/1 5.1 */ -#include -extern -#ifdef __cplusplus -"C" -#endif -int unsetenv (const char *name); - ]], - [[]])], - [gt_cv_func_unsetenv_ret='int'], - [gt_cv_func_unsetenv_ret='void'])]) - if test $gt_cv_func_unsetenv_ret = 'void'; then - AC_DEFINE([VOID_UNSETENV], [1], [Define to 1 if unsetenv returns void - instead of int.]) - REPLACE_UNSETENV=1 - fi - - dnl Solaris 10 unsetenv does not remove all copies of a name. - dnl Haiku alpha 2 unsetenv gets confused by assignment to environ. - dnl OpenBSD 4.7 unsetenv("") does not fail. - AC_CACHE_CHECK([whether unsetenv obeys POSIX], - [gl_cv_func_unsetenv_works], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM([[ - #include - #include - extern char **environ; - ]GL_MDA_DEFINES], - [[ - char entry1[] = "a=1"; - char entry2[] = "b=2"; - char *env[] = { entry1, entry2, NULL }; - if (putenv ((char *) "a=1")) return 1; - if (putenv (entry2)) return 2; - entry2[0] = 'a'; - unsetenv ("a"); - if (getenv ("a")) return 3; - if (!unsetenv ("") || errno != EINVAL) return 4; - entry2[0] = 'b'; - environ = env; - if (!getenv ("a")) return 5; - entry2[0] = 'a'; - unsetenv ("a"); - if (getenv ("a")) return 6; - ]])], - [gl_cv_func_unsetenv_works=yes], - [gl_cv_func_unsetenv_works=no], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu*) gl_cv_func_unsetenv_works="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_unsetenv_works="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_unsetenv_works" in - *yes) ;; - *) - REPLACE_UNSETENV=1 - ;; - esac - fi -]) -m4trace:gnulib-m4/setenv.m4:152: -1- AC_DEFUN([gl_PREREQ_SETENV], [ - AC_REQUIRE([gl_ENVIRON]) - AC_CHECK_HEADERS_ONCE([unistd.h]) - AC_CHECK_HEADERS([search.h]) - gl_CHECK_FUNCS_ANDROID([tsearch], [[#include ]]) -]) -m4trace:gnulib-m4/setenv.m4:161: -1- AC_DEFUN([gl_PREREQ_UNSETENV], [ - AC_REQUIRE([gl_ENVIRON]) - AC_CHECK_HEADERS_ONCE([unistd.h]) -]) -m4trace:gnulib-m4/setlocale.m4:7: -1- AC_DEFUN([gl_FUNC_SETLOCALE], [ - AC_REQUIRE([gl_LOCALE_H_DEFAULTS]) - AC_REQUIRE([gl_FUNC_SETLOCALE_NULL]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - dnl Test whether we need to improve on the general working of setlocale. - NEED_SETLOCALE_IMPROVED=0 - case "$host_os" in - dnl On native Windows systems, setlocale(category,NULL) does not look at - dnl the environment variables LC_ALL, category, and LANG. - mingw* | windows*) NEED_SETLOCALE_IMPROVED=1 ;; - dnl On Cygwin 1.5.x, setlocale always succeeds but setlocale(LC_CTYPE,NULL) - dnl is then still "C". - cygwin*) - case `uname -r` in - 1.5.*) NEED_SETLOCALE_IMPROVED=1 ;; - esac - ;; - dnl On Android 4.3, setlocale(category,"C") always fails. - *) - AC_CACHE_CHECK([whether setlocale supports the C locale], - [gl_cv_func_setlocale_works], - [AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -int main () -{ - return setlocale (LC_ALL, "C") == NULL; -}]])], - [gl_cv_func_setlocale_works=yes], - [gl_cv_func_setlocale_works=no], - [case "$host_os" in - # Guess no on Android. - linux*-android*) gl_cv_func_setlocale_works="guessing no";; - # Guess yes otherwise. - *) gl_cv_func_setlocale_works="guessing yes";; - esac - ]) - ]) - case "$gl_cv_func_setlocale_works" in - *yes) ;; - *) NEED_SETLOCALE_IMPROVED=1 ;; - esac - ;; - esac - AC_DEFINE_UNQUOTED([NEED_SETLOCALE_IMPROVED], [$NEED_SETLOCALE_IMPROVED], - [Define to 1 to enable general improvements of setlocale.]) - - dnl Test whether we need a multithread-safe setlocale(category,NULL). - NEED_SETLOCALE_MTSAFE=0 - if test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0; then - NEED_SETLOCALE_MTSAFE=1 - fi - AC_DEFINE_UNQUOTED([NEED_SETLOCALE_MTSAFE], [$NEED_SETLOCALE_MTSAFE], - [Define to 1 to enable a multithread-safety fix of setlocale.]) - - if test $NEED_SETLOCALE_IMPROVED = 1 || test $NEED_SETLOCALE_MTSAFE = 1; then - REPLACE_SETLOCALE=1 - fi - - if test $NEED_SETLOCALE_MTSAFE = 1; then - SETLOCALE_LIB="$SETLOCALE_NULL_LIB" - else - SETLOCALE_LIB= - fi - dnl SETLOCALE_LIB is expected to be '-pthread' or '-lpthread' on AIX with gcc - dnl or xlc, and empty otherwise. - AC_SUBST([SETLOCALE_LIB]) - dnl For backward compatibility. - LIB_SETLOCALE="$SETLOCALE_LIB" - AC_SUBST([LIB_SETLOCALE]) -]) -m4trace:gnulib-m4/setlocale.m4:82: -1- AC_DEFUN([gl_PREREQ_SETLOCALE], [ - dnl No need to check for CFLocaleCopyPreferredLanguages and - dnl CFPreferencesCopyAppValue because lib/setlocale.c is not used on Mac OS X. - dnl (The Mac OS X specific code is only used in libintl.) - : -]) -m4trace:gnulib-m4/setlocale_null.m4:7: -1- AC_DEFUN([gl_FUNC_SETLOCALE_NULL], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_PTHREADLIB]) - AC_CHECK_HEADERS_ONCE([threads.h]) - - AC_CACHE_CHECK([whether setlocale (LC_ALL, NULL) is multithread-safe], - [gl_cv_func_setlocale_null_all_mtsafe], - [case "$host_os" in - # Guess no on musl libc, macOS, FreeBSD, NetBSD, OpenBSD, AIX, Haiku. - *-musl* | midipix* | darwin* | freebsd* | midnightbsd* | netbsd* | openbsd* | aix* | haiku*) - gl_cv_func_setlocale_null_all_mtsafe=no ;; - # Guess no on Cygwin < 3.4.6. - cygwin*) - AC_EGREP_CPP([Lucky user], - [ -#if defined __CYGWIN__ - #include - #if CYGWIN_VERSION_DLL_COMBINED >= CYGWIN_VERSION_DLL_MAKE_COMBINED (3004, 6) - Lucky user - #endif -#endif - ], - [gl_cv_func_setlocale_null_all_mtsafe=yes], - [gl_cv_func_setlocale_null_all_mtsafe=no]) - ;; - # Guess yes on glibc, HP-UX, IRIX, Solaris, native Windows. - *-gnu* | gnu* | hpux* | irix* | solaris* | mingw* | windows*) - gl_cv_func_setlocale_null_all_mtsafe=yes ;; - # If we don't know, obey --enable-cross-guesses. - *) - gl_cv_func_setlocale_null_all_mtsafe="$gl_cross_guess_normal" ;; - esac - ]) - dnl On platforms without multithreading, there is no issue. - case "$host_os" in - mingw* | windows*) ;; - *) - if test $gl_pthread_api = no && test $ac_cv_header_threads_h = no; then - gl_cv_func_setlocale_null_all_mtsafe="trivially yes" - fi - ;; - esac - case "$gl_cv_func_setlocale_null_all_mtsafe" in - *yes) SETLOCALE_NULL_ALL_MTSAFE=1 ;; - *) SETLOCALE_NULL_ALL_MTSAFE=0 ;; - esac - AC_DEFINE_UNQUOTED([SETLOCALE_NULL_ALL_MTSAFE], [$SETLOCALE_NULL_ALL_MTSAFE], - [Define to 1 if setlocale (LC_ALL, NULL) is multithread-safe.]) - - dnl This is about a single category (not LC_ALL). - AC_CACHE_CHECK([whether setlocale (category, NULL) is multithread-safe], - [gl_cv_func_setlocale_null_one_mtsafe], - [case "$host_os" in - # Guess no on OpenBSD, AIX. - openbsd* | aix*) - gl_cv_func_setlocale_null_one_mtsafe=no ;; - # Guess yes on glibc, musl libc, macOS, FreeBSD, NetBSD, HP-UX, IRIX, Solaris, Haiku, Cygwin, native Windows. - *-gnu* | gnu* | *-musl* | midipix* | darwin* | freebsd* | midnightbsd* | netbsd* | hpux* | irix* | solaris* | haiku* | cygwin* | mingw* | windows*) - gl_cv_func_setlocale_null_one_mtsafe=yes ;; - # If we don't know, obey --enable-cross-guesses. - *) - gl_cv_func_setlocale_null_one_mtsafe="$gl_cross_guess_normal" ;; - esac - ]) - dnl On platforms without multithreading, there is no issue. - case "$host_os" in - mingw* | windows*) ;; - *) - if test $gl_pthread_api = no && test $ac_cv_header_threads_h = no; then - gl_cv_func_setlocale_null_one_mtsafe="trivially yes" - fi - ;; - esac - case "$gl_cv_func_setlocale_null_one_mtsafe" in - *yes) SETLOCALE_NULL_ONE_MTSAFE=1 ;; - *) SETLOCALE_NULL_ONE_MTSAFE=0 ;; - esac - AC_DEFINE_UNQUOTED([SETLOCALE_NULL_ONE_MTSAFE], [$SETLOCALE_NULL_ONE_MTSAFE], - [Define to 1 if setlocale (category, NULL) is multithread-safe.]) - - dnl Determine link dependencies of lib/setlocale_null.c and lib/setlocale-lock.c. - if test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0; then - case "$host_os" in - mingw* | windows*) - SETLOCALE_NULL_LIB= - ;; - *) - gl_WEAK_SYMBOLS - case "$gl_cv_have_weak" in - *yes) SETLOCALE_NULL_LIB= ;; - *) SETLOCALE_NULL_LIB="$LIBPTHREAD" ;; - esac - ;; - esac - else - SETLOCALE_NULL_LIB= - fi - dnl SETLOCALE_NULL_LIB is expected to be '-pthread' or '-lpthread' on AIX - dnl with gcc or xlc, and empty otherwise. - AC_SUBST([SETLOCALE_NULL_LIB]) - dnl For backward compatibility. - LIB_SETLOCALE_NULL="$SETLOCALE_NULL_LIB" - AC_SUBST([LIB_SETLOCALE_NULL]) -]) -m4trace:gnulib-m4/setlocale_null.m4:114: -1- AC_DEFUN([gl_PREREQ_SETLOCALE_LOCK], [ - gl_VISIBILITY -]) -m4trace:gnulib-m4/signal_h.m4:7: -1- AC_DEFUN_ONCE([gl_SIGNAL_H], [ - AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) - AC_REQUIRE([gl_CHECK_TYPE_SIGSET_T]) - gl_NEXT_HEADERS([signal.h]) - -# AIX declares sig_atomic_t to already include volatile, and C89 compilers -# then choke on 'volatile sig_atomic_t'. C99 requires that it compile. - AC_CHECK_TYPE([volatile sig_atomic_t], [], - [HAVE_TYPE_VOLATILE_SIG_ATOMIC_T=0], [[ -#include - ]]) - - dnl Ensure the type pid_t gets defined. - AC_REQUIRE([AC_TYPE_PID_T]) - - AC_REQUIRE([AC_TYPE_UID_T]) - - dnl Persuade glibc to define sighandler_t. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - AC_CHECK_TYPE([sighandler_t], [], [HAVE_SIGHANDLER_T=0], [[ -#include - ]]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[#include - ]], [pthread_sigmask sigaction - sigaddset sigdelset sigemptyset sigfillset sigismember - sigpending sigprocmask]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/signal_h.m4:41: -1- AC_DEFUN([gl_CHECK_TYPE_SIGSET_T], [ - AC_CHECK_TYPES([sigset_t], - [gl_cv_type_sigset_t=yes], [gl_cv_type_sigset_t=no], - [[ - #include - /* Mingw defines sigset_t not in , but in . */ - #include - ]]) - if test $gl_cv_type_sigset_t != yes; then - HAVE_SIGSET_T=0 - fi -]) -m4trace:gnulib-m4/signal_h.m4:59: -1- AC_DEFUN([gl_SIGNAL_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_SIGNAL_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/signal_h.m4:71: -1- AC_DEFUN([gl_SIGNAL_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_SIGNAL_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTHREAD_SIGMASK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAISE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGPROCMASK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGACTION]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_SIGNAL_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) -]) -m4trace:gnulib-m4/signal_h.m4:84: -1- AC_DEFUN([gl_SIGNAL_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_POSIX_SIGNALBLOCKING=1; AC_SUBST([HAVE_POSIX_SIGNALBLOCKING]) - HAVE_PTHREAD_SIGMASK=1; AC_SUBST([HAVE_PTHREAD_SIGMASK]) - HAVE_RAISE=1; AC_SUBST([HAVE_RAISE]) - HAVE_SIGSET_T=1; AC_SUBST([HAVE_SIGSET_T]) - HAVE_SIGINFO_T=1; AC_SUBST([HAVE_SIGINFO_T]) - HAVE_SIGACTION=1; AC_SUBST([HAVE_SIGACTION]) - HAVE_STRUCT_SIGACTION_SA_SIGACTION=1; - AC_SUBST([HAVE_STRUCT_SIGACTION_SA_SIGACTION]) - HAVE_TYPE_VOLATILE_SIG_ATOMIC_T=1; - AC_SUBST([HAVE_TYPE_VOLATILE_SIG_ATOMIC_T]) - HAVE_SIGHANDLER_T=1; AC_SUBST([HAVE_SIGHANDLER_T]) - REPLACE_PTHREAD_SIGMASK=0; AC_SUBST([REPLACE_PTHREAD_SIGMASK]) - REPLACE_RAISE=0; AC_SUBST([REPLACE_RAISE]) -]) -m4trace:gnulib-m4/signalblocking.m4:12: -1- AC_DEFUN([gl_SIGNALBLOCKING], [ - AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) - AC_REQUIRE([gl_CHECK_TYPE_SIGSET_T]) - HAVE_POSIX_SIGNALBLOCKING=0 - if test "$gl_cv_type_sigset_t" = yes; then - AC_CHECK_FUNC([sigprocmask], [HAVE_POSIX_SIGNALBLOCKING=1]) - fi -]) -m4trace:gnulib-m4/signalblocking.m4:23: -1- AC_DEFUN([gl_PREREQ_SIGPROCMASK], [:]) -m4trace:gnulib-m4/sigpipe.m4:9: -1- AC_DEFUN([gl_SIGNAL_SIGPIPE], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_SIGNAL_SIGPIPE_BODY]) -]) -m4trace:gnulib-m4/sigpipe.m4:16: -1- AC_DEFUN([gl_SIGNAL_SIGPIPE_BODY], [ - AC_REQUIRE([AC_PROG_CC]) - AC_CACHE_CHECK([for SIGPIPE], [gl_cv_header_signal_h_SIGPIPE], [ - AC_EGREP_CPP([booboo],[ -#include -#if !defined SIGPIPE -booboo -#endif - ], - [gl_cv_header_signal_h_SIGPIPE=no], - [gl_cv_header_signal_h_SIGPIPE=yes]) - ]) -]) -m4trace:gnulib-m4/ssize_t.m4:10: -1- AC_DEFUN([gt_TYPE_SSIZE_T], [ - AC_CACHE_CHECK([for ssize_t], [gl_cv_ssize_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[int x = sizeof (ssize_t *) + sizeof (ssize_t); - return !x;]])], - [gl_cv_ssize_t=yes], [gl_cv_ssize_t=no])]) - if test $gl_cv_ssize_t = no; then - dnl On 64-bit native Windows, ssize_t needs to be defined as 'long long', - dnl for consistency with the 64-bit size_t. - AC_CACHE_CHECK([whether size_t is wider than 'long'], [gl_cv_size_t_large], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - typedef int array [2 * (sizeof (size_t) > sizeof (long)) - 1]; - ]])], - [gl_cv_size_t_large=yes], [gl_cv_size_t_large=no])]) - if test $gl_cv_size_t_large = yes; then - gl_def_ssize_t='long long' - else - gl_def_ssize_t='long' - fi - AC_DEFINE_UNQUOTED([ssize_t], [$gl_def_ssize_t], - [Define as a signed type of the same size as size_t.]) - fi -]) -m4trace:gnulib-m4/stat-time.m4:20: -1- AC_DEFUN([gl_STAT_TIME], [ - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_CHECK_HEADERS_ONCE([sys/time.h]) - - AC_CHECK_MEMBERS([struct stat.st_atim.tv_nsec], - [AC_CACHE_CHECK([whether struct stat.st_atim is of type struct timespec], - [ac_cv_typeof_struct_stat_st_atim_is_struct_timespec], - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM( - [[ - #include - #include - #if HAVE_SYS_TIME_H - # include - #endif - #include - struct timespec ts; - struct stat st; - ]], - [[ - st.st_atim = ts; - ]])], - [ac_cv_typeof_struct_stat_st_atim_is_struct_timespec=yes], - [ac_cv_typeof_struct_stat_st_atim_is_struct_timespec=no])]) - if test $ac_cv_typeof_struct_stat_st_atim_is_struct_timespec = yes; then - AC_DEFINE([TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC], [1], - [Define to 1 if the type of the st_atim member of a struct stat is - struct timespec.]) - fi], - [AC_CHECK_MEMBERS([struct stat.st_atimespec.tv_nsec], [], - [AC_CHECK_MEMBERS([struct stat.st_atimensec], [], - [AC_CHECK_MEMBERS([struct stat.st_atim.st__tim.tv_nsec], [], [], - [#include - #include ])], - [#include - #include ])], - [#include - #include ])], - [#include - #include ]) -]) -m4trace:gnulib-m4/stat-time.m4:70: -1- AC_DEFUN([gl_STAT_BIRTHTIME], [ - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - AC_CHECK_HEADERS_ONCE([sys/time.h]) - AC_CHECK_MEMBERS([struct stat.st_birthtimespec.tv_nsec], [], - [AC_CHECK_MEMBERS([struct stat.st_birthtimensec], [], - [AC_CHECK_MEMBERS([struct stat.st_birthtim.tv_nsec], [], [], - [#include - #include ])], - [#include - #include ])], - [#include - #include ]) -]) -m4trace:gnulib-m4/stat.m4:9: -1- AC_DEFUN([gl_FUNC_STAT], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_SYS_STAT_H_DEFAULTS]) - AC_CHECK_FUNCS_ONCE([lstat]) - case "$host_os" in - mingw* | windows*) - dnl On this platform, the original stat() returns st_atime, st_mtime, - dnl st_ctime values that are affected by the time zone. - REPLACE_STAT=1 - ;; - *) - dnl AIX 7.1, Solaris 9, mingw64 mistakenly succeed on stat("file/"). - dnl (For mingw, this is due to a broken stat() override in libmingwex.a.) - dnl FreeBSD 7.2 mistakenly succeeds on stat("link-to-file/"). - AC_CACHE_CHECK([whether stat handles trailing slashes on files], - [gl_cv_func_stat_file_slash], - [touch conftest.tmp - # Assume that if we have lstat, we can also check symlinks. - if test $ac_cv_func_lstat = yes; then - ln -s conftest.tmp conftest.lnk - fi - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include -]], [[int result = 0; - struct stat st; - if (!stat ("conftest.tmp/", &st)) - result |= 1; -#if HAVE_LSTAT - if (!stat ("conftest.lnk/", &st)) - result |= 2; -#endif - return result; - ]])], - [gl_cv_func_stat_file_slash=yes], [gl_cv_func_stat_file_slash=no], - [case "$host_os" in - # Guess yes on Linux systems. - linux-* | linux) gl_cv_func_stat_file_slash="guessing yes" ;; - # Guess yes on systems that emulate the Linux system calls. - midipix*) gl_cv_func_stat_file_slash="guessing yes" ;; - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_stat_file_slash="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_stat_file_slash="$gl_cross_guess_normal" ;; - esac - ]) - rm -f conftest.tmp conftest.lnk]) - case $gl_cv_func_stat_file_slash in - *no) - REPLACE_STAT=1 - AC_DEFINE([REPLACE_FUNC_STAT_FILE], [1], [Define to 1 if stat needs - help when passed a file name with a trailing slash]);; - esac - case $host_os in - dnl macOS and Solaris stat can return a negative tv_nsec. - darwin* | solaris*) - REPLACE_FSTAT=1 ;; - esac - ;; - esac -]) -m4trace:gnulib-m4/stat.m4:73: -1- AC_DEFUN([gl_PREREQ_STAT], [ - AC_REQUIRE([gl_SYS_STAT_H]) - AC_REQUIRE([gl_PREREQ_STAT_W32]) - : -]) -m4trace:gnulib-m4/stat.m4:80: -1- AC_DEFUN([gl_PREREQ_STAT_W32], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - mingw* | windows*) - AC_CHECK_HEADERS([sdkddkver.h]) - ;; - esac -]) -m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ - AC_CACHE_CHECK([for alignas and alignof], - [gl_cv_header_working_stdalign_h], - [gl_saved_CFLAGS=$CFLAGS - for gl_working in "yes, keywords" "yes, macros"; do - AS_CASE([$gl_working], - [*stdalign.h*], [CFLAGS="$gl_saved_CFLAGS -DINCLUDE_STDALIGN_H"]) - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #ifdef INCLUDE_STDALIGN_H - #include - #endif - #include - - /* Test that alignof yields a result consistent with offsetof. - This catches GCC bug 52023 - . */ - #ifdef __cplusplus - template struct alignof_helper { char a; t b; }; - # define ao(type) offsetof (alignof_helper, b) - #else - # define ao(type) offsetof (struct { char a; type b; }, b) - #endif - char test_double[ao (double) % _Alignof (double) == 0 ? 1 : -1]; - char test_long[ao (long int) % _Alignof (long int) == 0 ? 1 : -1]; - char test_alignof[alignof (double) == _Alignof (double) ? 1 : -1]; - - /* Test alignas only on platforms where gnulib can help. */ - #if \ - ((defined __cplusplus && 201103 <= __cplusplus) \ - || (__TINYC__ && defined __attribute__) \ - || (defined __APPLE__ && defined __MACH__ \ - ? 4 < __GNUC__ + (1 <= __GNUC_MINOR__) \ - : __GNUC__) \ - || (__ia64 && (61200 <= __HP_cc || 61200 <= __HP_aCC)) \ - || __ICC || 0x590 <= __SUNPRO_C || 0x0600 <= __xlC__ \ - || 1300 <= _MSC_VER) - struct alignas_test { char c; char alignas (8) alignas_8; }; - char test_alignas[offsetof (struct alignas_test, alignas_8) == 8 - ? 1 : -1]; - #endif - ]])], - [gl_cv_header_working_stdalign_h=$gl_working], - [gl_cv_header_working_stdalign_h=no]) - - CFLAGS=$gl_saved_CFLAGS - test "$gl_cv_header_working_stdalign_h" != no && break - done]) - - AS_CASE([$gl_cv_header_working_stdalign_h], - [yes*keyword*], - [AC_DEFINE([HAVE_C_ALIGNASOF], [1], - [Define to 1 if the alignas and alignof keywords work.])]) - - dnl The "zz" puts this toward config.h's end, to avoid potential - dnl collisions with other definitions. - AH_VERBATIM([zzalignas], -[#if !defined HAVE_C_ALIGNASOF \ - && !(defined __cplusplus && 201103 <= __cplusplus) \ +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_C_ALIGNASOF]) +m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C_ALIGNASOF$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_C_ALIGNASOF], [/* Define to 1 if the alignas and alignof keywords work. */ +@%:@undef HAVE_C_ALIGNASOF]) +m4trace:configure.ac:114: -1- AH_OUTPUT([zzalignas], [#if !defined HAVE_C_ALIGNASOF \\ + && !(defined __cplusplus && 201103 <= __cplusplus) \\ && !defined alignof # if defined HAVE_STDALIGN_H # include @@ -12904,22 +1748,22 @@ m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ requirement of a structure member (i.e., slot or field) that is of type TYPE, as an integer constant expression. - This differs from GCC's and clang's __alignof__ operator, which can + This differs from GCC\'s and clang\'s __alignof__ operator, which can yield a better-performing alignment for an object of that type. For example, on x86 with GCC and on Linux/x86 with clang, __alignof__ (double) and __alignof__ (long long) are 8, whereas alignof (double) and alignof (long long) are 4 unless the option - '-malign-double' is used. + \'-malign-double\' is used. - The result cannot be used as a value for an 'enum' constant, if you + The result cannot be used as a value for an \'enum\' constant, if you want to be portable to HP-UX 10.20 cc and AIX 3.2.5 xlc. */ /* GCC releases before GCC 4.9 had a bug in _Alignof. See GCC bug 52023 . clang versions < 8.0.0 have the same bug. */ -# if (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112 \ - || (defined __GNUC__ && __GNUC__ < 4 + (__GNUC_MINOR__ < 9) \ - && !defined __clang__) \ +# if (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112 \\ + || (defined __GNUC__ && __GNUC__ < 4 + (__GNUC_MINOR__ < 9) \\ + && !defined __clang__) \\ || (defined __clang__ && __clang_major__ < 8)) # undef/**/_Alignof # ifdef __cplusplus @@ -12957,8 +1801,8 @@ m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ aligns the address of FOO and the offset of BAR to be multiples of 8. - A should be a power of two that is at least the type's alignment - and at most the implementation's alignment limit. This limit is + A should be a power of two that is at least the type\'s alignment + and at most the implementation\'s alignment limit. This limit is 2**28 on typical GNUish hosts, and 2**13 on MSVC. To be portable to MSVC through at least version 10.0, A should be an integer constant, as MSVC does not support expressions such as 1 << 3. @@ -12975,12 +1819,12 @@ m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ # if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112 # if defined __cplusplus && (201103 <= __cplusplus || defined _MSC_VER) # define _Alignas(a) alignas (a) -# elif (!defined __attribute__ \ - && ((defined __APPLE__ && defined __MACH__ \ - ? 4 < __GNUC__ + (1 <= __GNUC_MINOR__) \ - : __GNUC__ && !defined __ibmxl__) \ - || (4 <= __clang_major__) \ - || (__ia64 && (61200 <= __HP_cc || 61200 <= __HP_aCC)) \ +# elif (!defined __attribute__ \\ + && ((defined __APPLE__ && defined __MACH__ \\ + ? 4 < __GNUC__ + (1 <= __GNUC_MINOR__) \\ + : __GNUC__ && !defined __ibmxl__) \\ + || (4 <= __clang_major__) \\ + || (__ia64 && (61200 <= __HP_cc || 61200 <= __HP_aCC)) \\ || __ICC || 0x590 <= __SUNPRO_C || 0x0600 <= __xlC__)) # define _Alignas(a) __attribute__ ((__aligned__ (a))) # elif 1300 <= _MSC_VER @@ -12988,9 +1832,9 @@ m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ # endif # endif # if !defined HAVE_STDALIGN_H -# if ((defined _Alignas \ - && !(defined __cplusplus \ - && (201103 <= __cplusplus || defined _MSC_VER))) \ +# if ((defined _Alignas \\ + && !(defined __cplusplus \\ + && (201103 <= __cplusplus || defined _MSC_VER))) \\ || (defined __STDC_VERSION__ && 201112 <= __STDC_VERSION__)) # define alignas _Alignas # endif @@ -13000,11878 +1844,6165 @@ m4trace:gnulib-m4/stdalign.m4:12: -1- AC_DEFUN([gl_ALIGNASOF], [ # include # endif #endif]) -]) -m4trace:gnulib-m4/stdalign.m4:190: -1- AC_DEFUN([gl_STDALIGN_H], [ - AC_REQUIRE([gl_ALIGNASOF]) - if test "$gl_cv_header_working_stdalign_h" = no; then - GL_GENERATE_STDALIGN_H=true - else - GL_GENERATE_STDALIGN_H=false - fi - - gl_CHECK_NEXT_HEADERS([stdalign.h]) - if test $ac_cv_header_stdalign_h = yes; then - HAVE_STDALIGN_H=1 - else - HAVE_STDALIGN_H=0 - fi - AC_SUBST([HAVE_STDALIGN_H]) -]) -m4trace:gnulib-m4/stddef_h.m4:9: -1- AC_DEFUN_ONCE([gl_STDDEF_H], [ - AC_REQUIRE([gl_STDDEF_H_DEFAULTS]) - AC_REQUIRE([gt_TYPE_WCHAR_T]) - - dnl Persuade OpenBSD to declare max_align_t. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - GL_GENERATE_STDDEF_H=false - - dnl Test whether the type max_align_t exists and whether its alignment - dnl "is as great as is supported by the implementation in all contexts". - AC_CACHE_CHECK([for good max_align_t], - [gl_cv_type_max_align_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[/* On FreeBSD 12.0/x86, max_align_t defined by has - the correct alignment with the default (wrong) definition of - _Alignof, but a wrong alignment as soon as we activate an - ISO C compliant _Alignof definition. */ - #if ((defined __GNUC__ && 4 <= __GNUC__) || defined __clang__) && !defined __cplusplus - #define _Alignof(type) __builtin_offsetof (struct { char __a; type __b; }, __b) - #endif - #include - unsigned int s = sizeof (max_align_t); - #if defined __GNUC__ || defined __clang__ || defined __IBM__ALIGNOF__ - int check1[2 * (__alignof__ (double) <= __alignof__ (max_align_t)) - 1]; - int check2[2 * (__alignof__ (long double) <= __alignof__ (max_align_t)) - 1]; - #endif - typedef struct { char a; max_align_t b; } max_helper; - typedef struct { char a; long b; } long_helper; - typedef struct { char a; double b; } double_helper; - typedef struct { char a; long double b; } long_double_helper; - int check3[2 * (offsetof (long_helper, b) <= offsetof (max_helper, b)) - 1]; - int check4[2 * (offsetof (double_helper, b) <= offsetof (max_helper, b)) - 1]; - int check5[2 * (offsetof (long_double_helper, b) <= offsetof (max_helper, b)) - 1]; - ]])], - [gl_cv_type_max_align_t=yes], - [gl_cv_type_max_align_t=no]) - ]) - if test $gl_cv_type_max_align_t = no; then - HAVE_MAX_ALIGN_T=0 - GL_GENERATE_STDDEF_H=true - fi - - if test $gt_cv_c_wchar_t = no; then - HAVE_WCHAR_T=0 - GL_GENERATE_STDDEF_H=true - fi - - AC_CACHE_CHECK([whether NULL can be used in arbitrary expressions], - [gl_cv_decl_null_works], - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include - int test[2 * (sizeof NULL == sizeof (void *)) -1]; -]])], - [gl_cv_decl_null_works=yes], - [gl_cv_decl_null_works=no])]) - if test $gl_cv_decl_null_works = no; then - REPLACE_NULL=1 - GL_GENERATE_STDDEF_H=true - fi - - AC_CACHE_CHECK([for unreachable], - [gl_cv_func_unreachable], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[unreachable (); - ]])], - [gl_cv_func_unreachable=yes], - [gl_cv_func_unreachable=no]) - ]) - if test $gl_cv_func_unreachable = no; then - GL_GENERATE_STDDEF_H=true - fi - - if $GL_GENERATE_STDDEF_H; then - gl_NEXT_HEADERS([stddef.h]) - fi -]) -m4trace:gnulib-m4/stddef_h.m4:95: -1- AC_DEFUN([gl_STDDEF_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_STDDEF_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) -]) -m4trace:gnulib-m4/stddef_h.m4:105: -1- AC_DEFUN([gl_STDDEF_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_STDDEF_H_MODULE_INDICATOR_DEFAULTS], [ - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_STDDEF_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_STDDEF_H_DEFAULTS]) -]) -m4trace:gnulib-m4/stddef_h.m4:113: -1- AC_DEFUN([gl_STDDEF_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - REPLACE_NULL=0; AC_SUBST([REPLACE_NULL]) - HAVE_MAX_ALIGN_T=1; AC_SUBST([HAVE_MAX_ALIGN_T]) - HAVE_WCHAR_T=1; AC_SUBST([HAVE_WCHAR_T]) -]) -m4trace:gnulib-m4/stdint.m4:12: -1- AC_DEFUN_ONCE([gl_STDINT_H], [ - AC_PREREQ([2.59])dnl - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - AC_REQUIRE([gl_LIMITS_H]) - AC_REQUIRE([gt_TYPE_WINT_T]) - - dnl For backward compatibility. Some packages may still be testing these - dnl macros. - AC_DEFINE([HAVE_LONG_LONG_INT], [1], - [Define to 1 if the system has the type 'long long int'.]) - AC_DEFINE([HAVE_UNSIGNED_LONG_LONG_INT], [1], - [Define to 1 if the system has the type 'unsigned long long int'.]) - - dnl Check for , in the same way as gl_WCHAR_H does. - AC_CHECK_HEADERS_ONCE([wchar.h]) - if test $ac_cv_header_wchar_h = yes; then - HAVE_WCHAR_H=1 - else - HAVE_WCHAR_H=0 - fi - AC_SUBST([HAVE_WCHAR_H]) - - dnl Check for . - AC_CHECK_HEADERS_ONCE([inttypes.h]) - if test $ac_cv_header_inttypes_h = yes; then - HAVE_INTTYPES_H=1 - else - HAVE_INTTYPES_H=0 - fi - AC_SUBST([HAVE_INTTYPES_H]) - - dnl Check for . - AC_CHECK_HEADERS_ONCE([sys/types.h]) - if test $ac_cv_header_sys_types_h = yes; then - HAVE_SYS_TYPES_H=1 - else - HAVE_SYS_TYPES_H=0 - fi - AC_SUBST([HAVE_SYS_TYPES_H]) - - gl_CHECK_NEXT_HEADERS([stdint.h]) - if test $ac_cv_header_stdint_h = yes; then - HAVE_STDINT_H=1 - else - HAVE_STDINT_H=0 - fi - AC_SUBST([HAVE_STDINT_H]) - - dnl Now see whether we need a substitute . - if test $ac_cv_header_stdint_h = yes; then - AC_CACHE_CHECK([whether stdint.h conforms to C99], - [gl_cv_header_working_stdint_h], - [gl_cv_header_working_stdint_h=no - AC_COMPILE_IFELSE([ - AC_LANG_PROGRAM([[ -#define _GL_JUST_INCLUDE_SYSTEM_STDINT_H 1 /* work if build isn't clean */ -#define __STDC_CONSTANT_MACROS 1 -#define __STDC_LIMIT_MACROS 1 -#include -/* Dragonfly defines WCHAR_MIN, WCHAR_MAX only in . */ -#if !(defined WCHAR_MIN && defined WCHAR_MAX) -#error "WCHAR_MIN, WCHAR_MAX not defined in " -#endif -] -gl_STDINT_INCLUDES -[ -#ifdef INT8_MAX -int8_t a1 = INT8_MAX; -int8_t a1min = INT8_MIN; -#endif -#ifdef INT16_MAX -int16_t a2 = INT16_MAX; -int16_t a2min = INT16_MIN; -#endif -#ifdef INT32_MAX -int32_t a3 = INT32_MAX; -int32_t a3min = INT32_MIN; -#endif -#ifdef INT64_MAX -int64_t a4 = INT64_MAX; -int64_t a4min = INT64_MIN; -#endif -#ifdef UINT8_MAX -uint8_t b1 = UINT8_MAX; -#else -typedef int b1[(unsigned char) -1 != 255 ? 1 : -1]; -#endif -#ifdef UINT16_MAX -uint16_t b2 = UINT16_MAX; -#endif -#ifdef UINT32_MAX -uint32_t b3 = UINT32_MAX; -#endif -#ifdef UINT64_MAX -uint64_t b4 = UINT64_MAX; -#endif -int_least8_t c1 = INT8_C (0x7f); -int_least8_t c1max = INT_LEAST8_MAX; -int_least8_t c1min = INT_LEAST8_MIN; -int_least16_t c2 = INT16_C (0x7fff); -int_least16_t c2max = INT_LEAST16_MAX; -int_least16_t c2min = INT_LEAST16_MIN; -int_least32_t c3 = INT32_C (0x7fffffff); -int_least32_t c3max = INT_LEAST32_MAX; -int_least32_t c3min = INT_LEAST32_MIN; -int_least64_t c4 = INT64_C (0x7fffffffffffffff); -int_least64_t c4max = INT_LEAST64_MAX; -int_least64_t c4min = INT_LEAST64_MIN; -uint_least8_t d1 = UINT8_C (0xff); -uint_least8_t d1max = UINT_LEAST8_MAX; -uint_least16_t d2 = UINT16_C (0xffff); -uint_least16_t d2max = UINT_LEAST16_MAX; -uint_least32_t d3 = UINT32_C (0xffffffff); -uint_least32_t d3max = UINT_LEAST32_MAX; -uint_least64_t d4 = UINT64_C (0xffffffffffffffff); -uint_least64_t d4max = UINT_LEAST64_MAX; -int_fast8_t e1 = INT_FAST8_MAX; -int_fast8_t e1min = INT_FAST8_MIN; -int_fast16_t e2 = INT_FAST16_MAX; -int_fast16_t e2min = INT_FAST16_MIN; -int_fast32_t e3 = INT_FAST32_MAX; -int_fast32_t e3min = INT_FAST32_MIN; -int_fast64_t e4 = INT_FAST64_MAX; -int_fast64_t e4min = INT_FAST64_MIN; -uint_fast8_t f1 = UINT_FAST8_MAX; -uint_fast16_t f2 = UINT_FAST16_MAX; -uint_fast32_t f3 = UINT_FAST32_MAX; -uint_fast64_t f4 = UINT_FAST64_MAX; -#ifdef INTPTR_MAX -intptr_t g = INTPTR_MAX; -intptr_t gmin = INTPTR_MIN; -#endif -#ifdef UINTPTR_MAX -uintptr_t h = UINTPTR_MAX; -#endif -intmax_t i = INTMAX_MAX; -uintmax_t j = UINTMAX_MAX; - -/* Check that SIZE_MAX has the correct type, if possible. */ -/* ISO C 11 mandates _Generic, but GCC versions < 4.9 lack it. */ -#if 201112 <= __STDC_VERSION__ \ - && (!defined __GNUC__ || 4 < __GNUC__ + (9 <= __GNUC_MINOR__) \ - || defined __clang__) -int k = _Generic (SIZE_MAX, size_t: 0); -#elif (2 <= __GNUC__ || 4 <= __clang_major__ || defined __IBM__TYPEOF__ \ - || (0x5110 <= __SUNPRO_C && !__STDC__)) -extern size_t k; -extern __typeof__ (SIZE_MAX) k; -#endif - -#include /* for CHAR_BIT */ -#define TYPE_MINIMUM(t) \ - ((t) ((t) 0 < (t) -1 ? (t) 0 : ~ TYPE_MAXIMUM (t))) -#define TYPE_MAXIMUM(t) \ - ((t) ((t) 0 < (t) -1 \ - ? (t) -1 \ - : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1))) -struct s { - int check_PTRDIFF: - PTRDIFF_MIN == TYPE_MINIMUM (ptrdiff_t) - && PTRDIFF_MAX == TYPE_MAXIMUM (ptrdiff_t) - ? 1 : -1; - /* Detect bug in FreeBSD 6.0/ia64 and FreeBSD 13.0/arm64. */ - int check_SIG_ATOMIC: - SIG_ATOMIC_MIN == TYPE_MINIMUM (sig_atomic_t) - && SIG_ATOMIC_MAX == TYPE_MAXIMUM (sig_atomic_t) - ? 1 : -1; - int check_SIZE: SIZE_MAX == TYPE_MAXIMUM (size_t) ? 1 : -1; - int check_WCHAR: - WCHAR_MIN == TYPE_MINIMUM (wchar_t) - && WCHAR_MAX == TYPE_MAXIMUM (wchar_t) - ? 1 : -1; - /* Detect bug in mingw. */ - int check_WINT: - WINT_MIN == TYPE_MINIMUM (wint_t) - && WINT_MAX == TYPE_MAXIMUM (wint_t) - ? 1 : -1; - - /* Detect bugs in glibc 2.4 and Solaris 10 stdint.h, among others. */ - int check_UINT8_C: - (-1 < UINT8_C (0)) == (-1 < (uint_least8_t) 0) ? 1 : -1; - int check_UINT16_C: - (-1 < UINT16_C (0)) == (-1 < (uint_least16_t) 0) ? 1 : -1; - - /* Detect bugs in OpenBSD 3.9 stdint.h. */ -#ifdef UINT8_MAX - int check_uint8: (uint8_t) -1 == UINT8_MAX ? 1 : -1; -#endif -#ifdef UINT16_MAX - int check_uint16: (uint16_t) -1 == UINT16_MAX ? 1 : -1; -#endif -#ifdef UINT32_MAX - int check_uint32: (uint32_t) -1 == UINT32_MAX ? 1 : -1; -#endif -#ifdef UINT64_MAX - int check_uint64: (uint64_t) -1 == UINT64_MAX ? 1 : -1; -#endif - int check_uint_least8: (uint_least8_t) -1 == UINT_LEAST8_MAX ? 1 : -1; - int check_uint_least16: (uint_least16_t) -1 == UINT_LEAST16_MAX ? 1 : -1; - int check_uint_least32: (uint_least32_t) -1 == UINT_LEAST32_MAX ? 1 : -1; - int check_uint_least64: (uint_least64_t) -1 == UINT_LEAST64_MAX ? 1 : -1; - int check_uint_fast8: (uint_fast8_t) -1 == UINT_FAST8_MAX ? 1 : -1; - int check_uint_fast16: (uint_fast16_t) -1 == UINT_FAST16_MAX ? 1 : -1; - int check_uint_fast32: (uint_fast32_t) -1 == UINT_FAST32_MAX ? 1 : -1; - int check_uint_fast64: (uint_fast64_t) -1 == UINT_FAST64_MAX ? 1 : -1; - int check_uintptr: (uintptr_t) -1 == UINTPTR_MAX ? 1 : -1; - int check_uintmax: (uintmax_t) -1 == UINTMAX_MAX ? 1 : -1; - int check_size: (size_t) -1 == SIZE_MAX ? 1 : -1; -}; - ]])], - [dnl Determine whether the various *_MIN, *_MAX macros are usable - dnl in preprocessor expression. We could do it by compiling a test - dnl program for each of these macros. It is faster to run a program - dnl that inspects the macro expansion. - dnl This detects a bug on HP-UX 11.23/ia64. - AC_RUN_IFELSE([ - AC_LANG_PROGRAM([[ -#define _GL_JUST_INCLUDE_SYSTEM_STDINT_H 1 /* work if build isn't clean */ -#define __STDC_CONSTANT_MACROS 1 -#define __STDC_LIMIT_MACROS 1 -#include -] -gl_STDINT_INCLUDES -[ -#include -#include -#define MVAL(macro) MVAL1(macro) -#define MVAL1(expression) #expression -static const char *macro_values[] = - { -#ifdef INT8_MAX - MVAL (INT8_MAX), -#endif -#ifdef INT16_MAX - MVAL (INT16_MAX), -#endif -#ifdef INT32_MAX - MVAL (INT32_MAX), -#endif -#ifdef INT64_MAX - MVAL (INT64_MAX), -#endif -#ifdef UINT8_MAX - MVAL (UINT8_MAX), -#endif -#ifdef UINT16_MAX - MVAL (UINT16_MAX), -#endif -#ifdef UINT32_MAX - MVAL (UINT32_MAX), -#endif -#ifdef UINT64_MAX - MVAL (UINT64_MAX), -#endif - NULL - }; -]], [[ - const char **mv; - for (mv = macro_values; *mv != NULL; mv++) - { - const char *value = *mv; - /* Test whether it looks like a cast expression. */ - if (strncmp (value, "((unsigned int)"/*)*/, 15) == 0 - || strncmp (value, "((unsigned short)"/*)*/, 17) == 0 - || strncmp (value, "((unsigned char)"/*)*/, 16) == 0 - || strncmp (value, "((int)"/*)*/, 6) == 0 - || strncmp (value, "((signed short)"/*)*/, 15) == 0 - || strncmp (value, "((signed char)"/*)*/, 14) == 0) - return mv - macro_values + 1; - } - return 0; -]])], - [gl_cv_header_working_stdint_h=yes], - [], - [case "$host_os" in - # Guess yes on native Windows. - mingw* | windows*) gl_cv_header_working_stdint_h="guessing yes" ;; - # In general, assume it works. - *) gl_cv_header_working_stdint_h="guessing yes" ;; - esac - ]) - ]) - ]) - fi - - HAVE_C99_STDINT_H=0 - HAVE_SYS_BITYPES_H=0 - HAVE_SYS_INTTYPES_H=0 - GL_GENERATE_STDINT_H=true - case "$gl_cv_header_working_stdint_h" in - *yes) - HAVE_C99_STDINT_H=1 - dnl Now see whether the system works without - dnl __STDC_CONSTANT_MACROS/__STDC_LIMIT_MACROS defined. - dnl If not, there would be problems when stdint.h is included from C++. - AC_CACHE_CHECK([whether stdint.h works without ISO C predefines], - [gl_cv_header_stdint_without_STDC_macros], - [gl_cv_header_stdint_without_STDC_macros=no - AC_COMPILE_IFELSE([ - AC_LANG_PROGRAM([[ -#define _GL_JUST_INCLUDE_SYSTEM_STDINT_H 1 /* work if build isn't clean */ -#include -] -gl_STDINT_INCLUDES -[ -intmax_t im = INTMAX_MAX; -int32_t i32 = INT32_C (0x7fffffff); - ]])], - [gl_cv_header_stdint_without_STDC_macros=yes]) - ]) - - if test $gl_cv_header_stdint_without_STDC_macros = no; then - AC_DEFINE([__STDC_CONSTANT_MACROS], [1], - [Define to 1 if the system predates C++11.]) - AC_DEFINE([__STDC_LIMIT_MACROS], [1], - [Define to 1 if the system predates C++11.]) - fi - AC_CACHE_CHECK([whether stdint.h has UINTMAX_WIDTH etc.], - [gl_cv_header_stdint_width], - [gl_cv_header_stdint_width=no - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - /* Work if build is not clean. */ - #define _GL_JUST_INCLUDE_SYSTEM_STDINT_H 1 - #ifndef __STDC_WANT_IEC_60559_BFP_EXT__ - #define __STDC_WANT_IEC_60559_BFP_EXT__ 1 - #endif - #include - ]gl_STDINT_INCLUDES[ - int iw = UINTMAX_WIDTH; - ]])], - [gl_cv_header_stdint_width=yes])]) - if test "$gl_cv_header_stdint_width" = yes; then - GL_GENERATE_STDINT_H=false - fi - ;; - *) - dnl Check for , and for - dnl (used in Linux libc4 >= 4.6.7 and libc5). - AC_CHECK_HEADERS([sys/inttypes.h sys/bitypes.h]) - if test $ac_cv_header_sys_inttypes_h = yes; then - HAVE_SYS_INTTYPES_H=1 - fi - if test $ac_cv_header_sys_bitypes_h = yes; then - HAVE_SYS_BITYPES_H=1 - fi - gl_STDINT_TYPE_PROPERTIES - ;; - esac - - dnl The substitute stdint.h needs the substitute limit.h's _GL_INTEGER_WIDTH. - gl_REPLACE_LIMITS_H - - AC_SUBST([HAVE_C99_STDINT_H]) - AC_SUBST([HAVE_SYS_BITYPES_H]) - AC_SUBST([HAVE_SYS_INTTYPES_H]) -]) -m4trace:gnulib-m4/stdint.m4:374: -1- AC_DEFUN([gl_STDINT_BITSIZEOF], [ - dnl Use a shell loop, to avoid bloating configure, and - dnl - extra AH_TEMPLATE calls, so that autoheader knows what to put into - dnl config.h.in, - dnl - extra AC_SUBST calls, so that the right substitutions are made. - m4_foreach_w([gltype], [$1], - [AH_TEMPLATE([BITSIZEOF_]m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_]), - [Define to the number of bits in type ']gltype['.])]) - for gltype in $1 ; do - AC_CACHE_CHECK([for bit size of $gltype], [gl_cv_bitsizeof_${gltype}], - [AC_COMPUTE_INT([result], [sizeof ($gltype) * CHAR_BIT], - [$2 -#include ], [result=unknown]) - eval gl_cv_bitsizeof_${gltype}=\$result - ]) - eval result=\$gl_cv_bitsizeof_${gltype} - if test $result = unknown; then - dnl Use a nonempty default, because some compilers, such as IRIX 5 cc, - dnl do a syntax check even on unused #if conditions and give an error - dnl on valid C code like this: - dnl #if 0 - dnl # if > 32 - dnl # endif - dnl #endif - result=0 - fi - GLTYPE=`echo "$gltype" | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - AC_DEFINE_UNQUOTED([BITSIZEOF_${GLTYPE}], [$result]) - eval BITSIZEOF_${GLTYPE}=\$result - done - m4_foreach_w([gltype], [$1], - [AC_SUBST([BITSIZEOF_]m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_]))]) -]) -m4trace:gnulib-m4/stdint.m4:412: -1- AC_DEFUN([gl_CHECK_TYPES_SIGNED], [ - dnl Use a shell loop, to avoid bloating configure, and - dnl - extra AH_TEMPLATE calls, so that autoheader knows what to put into - dnl config.h.in, - dnl - extra AC_SUBST calls, so that the right substitutions are made. - m4_foreach_w([gltype], [$1], - [AH_TEMPLATE([HAVE_SIGNED_]m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_]), - [Define to 1 if ']gltype[' is a signed integer type.])]) - for gltype in $1 ; do - AC_CACHE_CHECK([whether $gltype is signed], [gl_cv_type_${gltype}_signed], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([$2[ - int verify[2 * (($gltype) -1 < ($gltype) 0) - 1];]])], - result=yes, result=no) - eval gl_cv_type_${gltype}_signed=\$result - ]) - eval result=\$gl_cv_type_${gltype}_signed - GLTYPE=`echo $gltype | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - if test "$result" = yes; then - AC_DEFINE_UNQUOTED([HAVE_SIGNED_${GLTYPE}], [1]) - eval HAVE_SIGNED_${GLTYPE}=1 - else - eval HAVE_SIGNED_${GLTYPE}=0 - fi - done - m4_foreach_w([gltype], [$1], - [AC_SUBST([HAVE_SIGNED_]m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_]))]) -]) -m4trace:gnulib-m4/stdint.m4:445: -1- AC_DEFUN([gl_INTEGER_TYPE_SUFFIX], [ - dnl Use a shell loop, to avoid bloating configure, and - dnl - extra AH_TEMPLATE calls, so that autoheader knows what to put into - dnl config.h.in, - dnl - extra AC_SUBST calls, so that the right substitutions are made. - m4_foreach_w([gltype], [$1], - [AH_TEMPLATE(m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_])[_SUFFIX], - [Define to l, ll, u, ul, ull, etc., as suitable for - constants of type ']gltype['.])]) - for gltype in $1 ; do - AC_CACHE_CHECK([for $gltype integer literal suffix], - [gl_cv_type_${gltype}_suffix], - [eval gl_cv_type_${gltype}_suffix=no - eval result=\$gl_cv_type_${gltype}_signed - if test "$result" = yes; then - glsufu= - else - glsufu=u - fi - for glsuf in "$glsufu" ${glsufu}l ${glsufu}ll ${glsufu}i64; do - case $glsuf in - '') gltype1='int';; - l) gltype1='long int';; - ll) gltype1='long long int';; - i64) gltype1='__int64';; - u) gltype1='unsigned int';; - ul) gltype1='unsigned long int';; - ull) gltype1='unsigned long long int';; - ui64)gltype1='unsigned __int64';; - esac - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([$2[ - extern $gltype foo; - extern $gltype1 foo;]])], - [eval gl_cv_type_${gltype}_suffix=\$glsuf]) - eval result=\$gl_cv_type_${gltype}_suffix - test "$result" != no && break - done]) - GLTYPE=`echo $gltype | tr 'abcdefghijklmnopqrstuvwxyz ' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ_'` - eval result=\$gl_cv_type_${gltype}_suffix - test "$result" = no && result= - eval ${GLTYPE}_SUFFIX=\$result - AC_DEFINE_UNQUOTED([${GLTYPE}_SUFFIX], [$result]) - done - m4_foreach_w([gltype], [$1], - [AC_SUBST(m4_translit(gltype,[abcdefghijklmnopqrstuvwxyz ],[ABCDEFGHIJKLMNOPQRSTUVWXYZ_])[_SUFFIX])]) -]) -m4trace:gnulib-m4/stdint.m4:495: -1- AC_DEFUN([gl_STDINT_INCLUDES], [[ - #include - #include - #if HAVE_WCHAR_H - # include - #endif -]]) -m4trace:gnulib-m4/stdint.m4:507: -1- AC_DEFUN([gl_STDINT_TYPE_PROPERTIES], [ - AC_REQUIRE([gl_MULTIARCH]) - if test $APPLE_UNIVERSAL_BUILD = 0; then - gl_STDINT_BITSIZEOF([ptrdiff_t size_t], - [gl_STDINT_INCLUDES]) - fi - gl_STDINT_BITSIZEOF([sig_atomic_t wchar_t wint_t], - [gl_STDINT_INCLUDES]) - gl_CHECK_TYPES_SIGNED([sig_atomic_t wchar_t wint_t], - [gl_STDINT_INCLUDES]) - gl_cv_type_ptrdiff_t_signed=yes - gl_cv_type_size_t_signed=no - if test $APPLE_UNIVERSAL_BUILD = 0; then - gl_INTEGER_TYPE_SUFFIX([ptrdiff_t size_t], - [gl_STDINT_INCLUDES]) - fi - gl_INTEGER_TYPE_SUFFIX([sig_atomic_t wchar_t wint_t], - [gl_STDINT_INCLUDES]) - - dnl If wint_t is smaller than 'int', it cannot satisfy the ISO C 99 - dnl requirement that wint_t is "unchanged by default argument promotions". - dnl In this case gnulib's and override wint_t. - dnl Set the variable BITSIZEOF_WINT_T accordingly. - if test $GNULIBHEADERS_OVERRIDE_WINT_T = 1; then - BITSIZEOF_WINT_T=32 - fi -]) -m4trace:gnulib-m4/stdio_h.m4:7: -1- AC_DEFUN([gl_STDIO_H_EARLY], [ - dnl Defining __USE_MINGW_ANSI_STDIO to 1 must be done early, because - dnl the results of several configure tests depend on it: The tests - dnl - checking whether snprintf returns a byte count as in C99... - dnl - checking whether snprintf truncates the result as in C99... - dnl - checking whether printf supports the 'F' directive... - dnl - checking whether printf supports the grouping flag... - dnl - checking whether printf supports the zero flag correctly... - dnl - checking whether printf supports infinite 'double' arguments... - dnl - checking whether printf supports large precisions... - dnl report 'yes' if __USE_MINGW_ANSI_STDIO is 1 but 'no' if - dnl __USE_MINGW_ANSI_STDIO is not set. - AH_VERBATIM([MINGW_ANSI_STDIO], -[/* Use GNU style printf and scanf. */ -#ifndef __USE_MINGW_ANSI_STDIO -# undef __USE_MINGW_ANSI_STDIO -#endif -]) - AC_DEFINE([__USE_MINGW_ANSI_STDIO]) -]) -m4trace:gnulib-m4/stdio_h.m4:29: -1- AC_DEFUN_ONCE([gl_STDIO_H], [ - AC_REQUIRE([gl_STDIO_H_DEFAULTS]) - gl_NEXT_HEADERS([stdio.h]) - - dnl Determine whether __USE_MINGW_ANSI_STDIO makes printf and - dnl inttypes.h behave like gnu instead of system; we must give our - dnl printf wrapper the right attribute to match. - AC_CACHE_CHECK([which flavor of printf attribute matches inttypes macros], - [gl_cv_func_printf_attribute_flavor], - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ - #define __STDC_FORMAT_MACROS 1 - #include - #include - /* For non-mingw systems, compilation will trivially succeed. - For mingw, compilation will succeed for older mingw (system - printf, "I64d") and fail for newer mingw (gnu printf, "lld"). */ - #if (defined _WIN32 && ! defined __CYGWIN__) && \ - (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) - extern char PRIdMAX_probe[sizeof PRIdMAX == sizeof "I64d" ? 1 : -1]; - #endif - ]])], [gl_cv_func_printf_attribute_flavor=system], - [gl_cv_func_printf_attribute_flavor=gnu])]) - if test "$gl_cv_func_printf_attribute_flavor" = gnu; then - AC_DEFINE([GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU], [1], - [Define to 1 if printf and friends should be labeled with - attribute "__gnu_printf__" instead of "__printf__"]) - fi - - dnl For defining _PRINTF_NAN_LEN_MAX. - gl_MUSL_LIBC - - dnl This ifdef is an optimization, to avoid performing a configure check whose - dnl result is not used. But it does not make the test of - dnl GNULIB_STDIO_H_NONBLOCKING or GNULIB_NONBLOCKING redundant. - m4_ifdef([gl_NONBLOCKING_IO], [ - gl_NONBLOCKING_IO - if test $gl_cv_have_nonblocking != yes; then - REPLACE_STDIO_READ_FUNCS=1 - fi - ]) - - dnl This ifdef is an optimization, to avoid performing a configure check whose - dnl result is not used. But it does not make the test of - dnl GNULIB_STDIO_H_SIGPIPE or GNULIB_SIGPIPE redundant. - m4_ifdef([gl_SIGNAL_SIGPIPE], [ - gl_SIGNAL_SIGPIPE - if test $gl_cv_header_signal_h_SIGPIPE != yes; then - REPLACE_STDIO_WRITE_FUNCS=1 - fi - ]) - dnl This ifdef is an optimization, to avoid performing a configure check whose - dnl result is not used. But it does not make the test of - dnl GNULIB_STDIO_H_NONBLOCKING or GNULIB_NONBLOCKING redundant. - m4_ifdef([gl_NONBLOCKING_IO], [ - gl_NONBLOCKING_IO - if test $gl_cv_have_nonblocking != yes; then - REPLACE_STDIO_WRITE_FUNCS=1 - fi - ]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use, and which is not - dnl guaranteed by both C89 and C11. - gl_WARN_ON_USE_PREPARE([[#include - ]], [dprintf fpurge fseeko ftello getdelim getline gets pclose popen - renameat snprintf tmpfile vdprintf vsnprintf]) - - AC_REQUIRE([AC_C_RESTRICT]) - - AC_CHECK_DECLS_ONCE([fcloseall]) - if test $ac_cv_have_decl_fcloseall = no; then - HAVE_DECL_FCLOSEALL=0 - fi - - AC_CHECK_DECLS_ONCE([getw]) - if test $ac_cv_have_decl_getw = no; then - HAVE_DECL_GETW=0 - fi - - AC_CHECK_DECLS_ONCE([putw]) - if test $ac_cv_have_decl_putw = no; then - HAVE_DECL_PUTW=0 - fi -]) -m4trace:gnulib-m4/stdio_h.m4:119: -1- AC_DEFUN([gl_STDIO_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_STDIO_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/stdio_h.m4:131: -1- AC_DEFUN([gl_STDIO_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_STDIO_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCLOSE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FDOPEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFLUSH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FGETC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FGETS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FOPEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FOPEN_GNU]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPURGE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPUTC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPUTS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREAD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREOPEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSCANF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSEEK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSEEKO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTELL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTELLO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FWRITE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETCHAR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDELIM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLINE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OBSTACK_PRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OBSTACK_PRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PCLOSE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PERROR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POPEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTCHAR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REMOVE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RENAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RENAMEAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SCANF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SNPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SPRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_NONBLOCKING]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TMPFILE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VASPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFSCANF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSCANF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VDPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFPRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VPRINTF_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSNPRINTF]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSPRINTF_POSIX]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FCLOSEALL], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FDOPEN], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FILENO], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETW], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_PUTW], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_TEMPNAM], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_STDIO_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_STDIO_H_DEFAULTS]) -]) -m4trace:gnulib-m4/stdio_h.m4:200: -1- AC_DEFUN([gl_STDIO_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_DECL_FCLOSEALL=1; AC_SUBST([HAVE_DECL_FCLOSEALL]) - HAVE_DECL_FPURGE=1; AC_SUBST([HAVE_DECL_FPURGE]) - HAVE_DECL_FSEEKO=1; AC_SUBST([HAVE_DECL_FSEEKO]) - HAVE_DECL_FTELLO=1; AC_SUBST([HAVE_DECL_FTELLO]) - HAVE_DECL_GETDELIM=1; AC_SUBST([HAVE_DECL_GETDELIM]) - HAVE_DECL_GETLINE=1; AC_SUBST([HAVE_DECL_GETLINE]) - HAVE_DECL_GETW=1; AC_SUBST([HAVE_DECL_GETW]) - HAVE_DECL_OBSTACK_PRINTF=1; AC_SUBST([HAVE_DECL_OBSTACK_PRINTF]) - HAVE_DECL_PUTW=1; AC_SUBST([HAVE_DECL_PUTW]) - HAVE_DECL_SNPRINTF=1; AC_SUBST([HAVE_DECL_SNPRINTF]) - HAVE_DECL_VSNPRINTF=1; AC_SUBST([HAVE_DECL_VSNPRINTF]) - HAVE_DPRINTF=1; AC_SUBST([HAVE_DPRINTF]) - HAVE_FSEEKO=1; AC_SUBST([HAVE_FSEEKO]) - HAVE_FTELLO=1; AC_SUBST([HAVE_FTELLO]) - HAVE_PCLOSE=1; AC_SUBST([HAVE_PCLOSE]) - HAVE_POPEN=1; AC_SUBST([HAVE_POPEN]) - HAVE_RENAMEAT=1; AC_SUBST([HAVE_RENAMEAT]) - HAVE_VASPRINTF=1; AC_SUBST([HAVE_VASPRINTF]) - HAVE_VDPRINTF=1; AC_SUBST([HAVE_VDPRINTF]) - REPLACE_DPRINTF=0; AC_SUBST([REPLACE_DPRINTF]) - REPLACE_FCLOSE=0; AC_SUBST([REPLACE_FCLOSE]) - REPLACE_FDOPEN=0; AC_SUBST([REPLACE_FDOPEN]) - REPLACE_FFLUSH=0; AC_SUBST([REPLACE_FFLUSH]) - REPLACE_FOPEN=0; AC_SUBST([REPLACE_FOPEN]) - REPLACE_FOPEN_FOR_FOPEN_GNU=0; AC_SUBST([REPLACE_FOPEN_FOR_FOPEN_GNU]) - REPLACE_FPRINTF=0; AC_SUBST([REPLACE_FPRINTF]) - REPLACE_FPURGE=0; AC_SUBST([REPLACE_FPURGE]) - REPLACE_FREOPEN=0; AC_SUBST([REPLACE_FREOPEN]) - REPLACE_FSEEK=0; AC_SUBST([REPLACE_FSEEK]) - REPLACE_FSEEKO=0; AC_SUBST([REPLACE_FSEEKO]) - REPLACE_FTELL=0; AC_SUBST([REPLACE_FTELL]) - REPLACE_FTELLO=0; AC_SUBST([REPLACE_FTELLO]) - REPLACE_GETDELIM=0; AC_SUBST([REPLACE_GETDELIM]) - REPLACE_GETLINE=0; AC_SUBST([REPLACE_GETLINE]) - REPLACE_OBSTACK_PRINTF=0; AC_SUBST([REPLACE_OBSTACK_PRINTF]) - REPLACE_PERROR=0; AC_SUBST([REPLACE_PERROR]) - REPLACE_POPEN=0; AC_SUBST([REPLACE_POPEN]) - REPLACE_PRINTF=0; AC_SUBST([REPLACE_PRINTF]) - REPLACE_REMOVE=0; AC_SUBST([REPLACE_REMOVE]) - REPLACE_RENAME=0; AC_SUBST([REPLACE_RENAME]) - REPLACE_RENAMEAT=0; AC_SUBST([REPLACE_RENAMEAT]) - REPLACE_SNPRINTF=0; AC_SUBST([REPLACE_SNPRINTF]) - REPLACE_SPRINTF=0; AC_SUBST([REPLACE_SPRINTF]) - REPLACE_STDIO_READ_FUNCS=0; AC_SUBST([REPLACE_STDIO_READ_FUNCS]) - REPLACE_STDIO_WRITE_FUNCS=0; AC_SUBST([REPLACE_STDIO_WRITE_FUNCS]) - REPLACE_TMPFILE=0; AC_SUBST([REPLACE_TMPFILE]) - REPLACE_VASPRINTF=0; AC_SUBST([REPLACE_VASPRINTF]) - REPLACE_VDPRINTF=0; AC_SUBST([REPLACE_VDPRINTF]) - REPLACE_VFPRINTF=0; AC_SUBST([REPLACE_VFPRINTF]) - REPLACE_VPRINTF=0; AC_SUBST([REPLACE_VPRINTF]) - REPLACE_VSNPRINTF=0; AC_SUBST([REPLACE_VSNPRINTF]) - REPLACE_VSPRINTF=0; AC_SUBST([REPLACE_VSPRINTF]) -]) -m4trace:gnulib-m4/stdlib_h.m4:7: -1- AC_DEFUN_ONCE([gl_STDLIB_H], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - gl_NEXT_HEADERS([stdlib.h]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use, and which is not - dnl guaranteed by C89. - gl_WARN_ON_USE_PREPARE([[#include -#if HAVE_SYS_LOADAVG_H -/* OpenIndiana has a bug: must be included before - . */ -# include -# include -#endif -#if HAVE_RANDOM_H -# include -#endif - ]], [_Exit aligned_alloc atoll canonicalize_file_name free - getloadavg getprogname getsubopt grantpt - initstate initstate_r mbstowcs mbtowc mkdtemp mkostemp mkostemps mkstemp - mkstemps posix_memalign posix_openpt ptsname ptsname_r qsort_r - random random_r reallocarray realpath rpmatch secure_getenv setenv - setstate setstate_r srandom srandom_r - strtod strtol strtold strtoll strtoul strtoull unlockpt unsetenv]) - - AC_REQUIRE([AC_C_RESTRICT]) - - dnl Test whether MB_CUR_MAX needs to be overridden. - dnl On Solaris 10, in UTF-8 locales, its value is 3 but needs to be 4. - dnl Fortunately, we can do this because on this platform MB_LEN_MAX is 5. - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gt_LOCALE_FR_UTF8]) - AC_CACHE_CHECK([whether MB_CUR_MAX is correct], - [gl_cv_macro_MB_CUR_MAX_good], - [ - dnl Initial guess, used when cross-compiling or when no suitable locale - dnl is present. -changequote(,)dnl - case "$host_os" in - # Guess no on Solaris. - solaris*) gl_cv_macro_MB_CUR_MAX_good="guessing no" ;; - # Guess yes otherwise. - *) gl_cv_macro_MB_CUR_MAX_good="guessing yes" ;; - esac -changequote([,])dnl - if test $LOCALE_FR_UTF8 != none; then - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -int main () -{ - int result = 0; - if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL) - { - if (MB_CUR_MAX < 4) - result |= 1; - } - return result; -}]])], - [gl_cv_macro_MB_CUR_MAX_good=yes], - [gl_cv_macro_MB_CUR_MAX_good=no], - [:]) - fi - ]) - case "$gl_cv_macro_MB_CUR_MAX_good" in - *yes) ;; - *) REPLACE_MB_CUR_MAX=1 ;; - esac - - AC_CHECK_DECLS_ONCE([ecvt]) - if test $ac_cv_have_decl_ecvt = no; then - HAVE_DECL_ECVT=0 - fi - AC_CHECK_DECLS_ONCE([fcvt]) - if test $ac_cv_have_decl_fcvt = no; then - HAVE_DECL_FCVT=0 - fi - AC_CHECK_DECLS_ONCE([gcvt]) - if test $ac_cv_have_decl_gcvt = no; then - HAVE_DECL_GCVT=0 - fi -]) -m4trace:gnulib-m4/stdlib_h.m4:96: -1- AC_DEFUN([gl_STDLIB_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_STDLIB_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/stdlib_h.m4:108: -1- AC_DEFUN([gl_STDLIB_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_STDLIB_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB__EXIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ALIGNED_ALLOC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ATOLL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CALLOC_GNU]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CALLOC_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CANONICALIZE_FILE_NAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREE_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOADAVG]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPROGNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETSUBOPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GRANTPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MALLOC_GNU]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MALLOC_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOWCS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBTOWC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDTEMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKOSTEMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKOSTEMPS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKSTEMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKSTEMPS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POSIX_MEMALIGN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POSIX_OPENPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTSNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTSNAME_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTENV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_QSORT_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAND]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RANDOM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RANDOM_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOCARRAY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOC_GNU]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOC_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALPATH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RPMATCH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SECURE_GETENV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETENV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOLD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOLL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOUL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOULL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYSTEM_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLOCKPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNSETENV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTOMB]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ECVT], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FCVT], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GCVT], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MKTEMP], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_PUTENV], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_STDLIB_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) -]) -m4trace:gnulib-m4/stdlib_h.m4:168: -1- AC_DEFUN([gl_STDLIB_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE__EXIT=1; AC_SUBST([HAVE__EXIT]) - HAVE_ALIGNED_ALLOC=1; AC_SUBST([HAVE_ALIGNED_ALLOC]) - HAVE_ATOLL=1; AC_SUBST([HAVE_ATOLL]) - HAVE_CANONICALIZE_FILE_NAME=1; AC_SUBST([HAVE_CANONICALIZE_FILE_NAME]) - HAVE_DECL_ECVT=1; AC_SUBST([HAVE_DECL_ECVT]) - HAVE_DECL_FCVT=1; AC_SUBST([HAVE_DECL_FCVT]) - HAVE_DECL_GCVT=1; AC_SUBST([HAVE_DECL_GCVT]) - HAVE_DECL_GETLOADAVG=1; AC_SUBST([HAVE_DECL_GETLOADAVG]) - HAVE_DECL_PROGRAM_INVOCATION_NAME=1; AC_SUBST([HAVE_DECL_PROGRAM_INVOCATION_NAME]) - HAVE_GETPROGNAME=1; AC_SUBST([HAVE_GETPROGNAME]) - HAVE_GETSUBOPT=1; AC_SUBST([HAVE_GETSUBOPT]) - HAVE_GRANTPT=1; AC_SUBST([HAVE_GRANTPT]) - HAVE_INITSTATE=1; AC_SUBST([HAVE_INITSTATE]) - HAVE_DECL_INITSTATE=1; AC_SUBST([HAVE_DECL_INITSTATE]) - HAVE_MBTOWC=1; AC_SUBST([HAVE_MBTOWC]) - HAVE_MKDTEMP=1; AC_SUBST([HAVE_MKDTEMP]) - HAVE_MKOSTEMP=1; AC_SUBST([HAVE_MKOSTEMP]) - HAVE_MKOSTEMPS=1; AC_SUBST([HAVE_MKOSTEMPS]) - HAVE_MKSTEMP=1; AC_SUBST([HAVE_MKSTEMP]) - HAVE_MKSTEMPS=1; AC_SUBST([HAVE_MKSTEMPS]) - HAVE_POSIX_MEMALIGN=1; AC_SUBST([HAVE_POSIX_MEMALIGN]) - HAVE_POSIX_OPENPT=1; AC_SUBST([HAVE_POSIX_OPENPT]) - HAVE_PTSNAME=1; AC_SUBST([HAVE_PTSNAME]) - HAVE_PTSNAME_R=1; AC_SUBST([HAVE_PTSNAME_R]) - HAVE_QSORT_R=1; AC_SUBST([HAVE_QSORT_R]) - HAVE_RANDOM=1; AC_SUBST([HAVE_RANDOM]) - HAVE_RANDOM_H=1; AC_SUBST([HAVE_RANDOM_H]) - HAVE_RANDOM_R=1; AC_SUBST([HAVE_RANDOM_R]) - HAVE_REALLOCARRAY=1; AC_SUBST([HAVE_REALLOCARRAY]) - HAVE_REALPATH=1; AC_SUBST([HAVE_REALPATH]) - HAVE_RPMATCH=1; AC_SUBST([HAVE_RPMATCH]) - HAVE_SECURE_GETENV=1; AC_SUBST([HAVE_SECURE_GETENV]) - HAVE_SETENV=1; AC_SUBST([HAVE_SETENV]) - HAVE_DECL_SETENV=1; AC_SUBST([HAVE_DECL_SETENV]) - HAVE_SETSTATE=1; AC_SUBST([HAVE_SETSTATE]) - HAVE_DECL_SETSTATE=1; AC_SUBST([HAVE_DECL_SETSTATE]) - HAVE_STRTOD=1; AC_SUBST([HAVE_STRTOD]) - HAVE_STRTOL=1; AC_SUBST([HAVE_STRTOL]) - HAVE_STRTOLD=1; AC_SUBST([HAVE_STRTOLD]) - HAVE_STRTOLL=1; AC_SUBST([HAVE_STRTOLL]) - HAVE_STRTOUL=1; AC_SUBST([HAVE_STRTOUL]) - HAVE_STRTOULL=1; AC_SUBST([HAVE_STRTOULL]) - HAVE_STRUCT_RANDOM_DATA=1; AC_SUBST([HAVE_STRUCT_RANDOM_DATA]) - HAVE_SYS_LOADAVG_H=0; AC_SUBST([HAVE_SYS_LOADAVG_H]) - HAVE_UNLOCKPT=1; AC_SUBST([HAVE_UNLOCKPT]) - HAVE_DECL_UNSETENV=1; AC_SUBST([HAVE_DECL_UNSETENV]) - REPLACE__EXIT=0; AC_SUBST([REPLACE__EXIT]) - REPLACE_ALIGNED_ALLOC=0; AC_SUBST([REPLACE_ALIGNED_ALLOC]) - REPLACE_CALLOC_FOR_CALLOC_GNU=0; AC_SUBST([REPLACE_CALLOC_FOR_CALLOC_GNU]) - REPLACE_CALLOC_FOR_CALLOC_POSIX=0; AC_SUBST([REPLACE_CALLOC_FOR_CALLOC_POSIX]) - REPLACE_CANONICALIZE_FILE_NAME=0; AC_SUBST([REPLACE_CANONICALIZE_FILE_NAME]) - REPLACE_FREE=0; AC_SUBST([REPLACE_FREE]) - REPLACE_GETLOADAVG=0; AC_SUBST([REPLACE_GETLOADAVG]) - REPLACE_GETPROGNAME=0; AC_SUBST([REPLACE_GETPROGNAME]) - REPLACE_GETSUBOPT=0; AC_SUBST([REPLACE_GETSUBOPT]) - REPLACE_INITSTATE=0; AC_SUBST([REPLACE_INITSTATE]) - REPLACE_MALLOC_FOR_MALLOC_GNU=0; AC_SUBST([REPLACE_MALLOC_FOR_MALLOC_GNU]) - REPLACE_MALLOC_FOR_MALLOC_POSIX=0; AC_SUBST([REPLACE_MALLOC_FOR_MALLOC_POSIX]) - REPLACE_MB_CUR_MAX=0; AC_SUBST([REPLACE_MB_CUR_MAX]) - REPLACE_MBSTOWCS=0; AC_SUBST([REPLACE_MBSTOWCS]) - REPLACE_MBTOWC=0; AC_SUBST([REPLACE_MBTOWC]) - REPLACE_MKOSTEMP=0; AC_SUBST([REPLACE_MKOSTEMP]) - REPLACE_MKOSTEMPS=0; AC_SUBST([REPLACE_MKOSTEMPS]) - REPLACE_MKSTEMP=0; AC_SUBST([REPLACE_MKSTEMP]) - REPLACE_POSIX_MEMALIGN=0; AC_SUBST([REPLACE_POSIX_MEMALIGN]) - REPLACE_POSIX_OPENPT=0; AC_SUBST([REPLACE_POSIX_OPENPT]) - REPLACE_PTSNAME=0; AC_SUBST([REPLACE_PTSNAME]) - REPLACE_PTSNAME_R=0; AC_SUBST([REPLACE_PTSNAME_R]) - REPLACE_PUTENV=0; AC_SUBST([REPLACE_PUTENV]) - REPLACE_QSORT_R=0; AC_SUBST([REPLACE_QSORT_R]) - REPLACE_RAND=0; AC_SUBST([REPLACE_RAND]) - REPLACE_RANDOM=0; AC_SUBST([REPLACE_RANDOM]) - REPLACE_RANDOM_R=0; AC_SUBST([REPLACE_RANDOM_R]) - REPLACE_REALLOC_FOR_REALLOC_GNU=0; AC_SUBST([REPLACE_REALLOC_FOR_REALLOC_GNU]) - REPLACE_REALLOC_FOR_REALLOC_POSIX=0; AC_SUBST([REPLACE_REALLOC_FOR_REALLOC_POSIX]) - REPLACE_REALLOCARRAY=0; AC_SUBST([REPLACE_REALLOCARRAY]) - REPLACE_REALPATH=0; AC_SUBST([REPLACE_REALPATH]) - REPLACE_SETENV=0; AC_SUBST([REPLACE_SETENV]) - REPLACE_SETSTATE=0; AC_SUBST([REPLACE_SETSTATE]) - REPLACE_STRTOD=0; AC_SUBST([REPLACE_STRTOD]) - REPLACE_STRTOL=0; AC_SUBST([REPLACE_STRTOL]) - REPLACE_STRTOLD=0; AC_SUBST([REPLACE_STRTOLD]) - REPLACE_STRTOLL=0; AC_SUBST([REPLACE_STRTOLL]) - REPLACE_STRTOUL=0; AC_SUBST([REPLACE_STRTOUL]) - REPLACE_STRTOULL=0; AC_SUBST([REPLACE_STRTOULL]) - REPLACE_UNSETENV=0; AC_SUBST([REPLACE_UNSETENV]) - REPLACE_WCTOMB=0; AC_SUBST([REPLACE_WCTOMB]) -]) -m4trace:gnulib-m4/strerror.m4:7: -1- AC_DEFUN([gl_FUNC_STRERROR], [ - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - AC_REQUIRE([gl_HEADER_ERRNO_H]) - AC_REQUIRE([gl_FUNC_STRERROR_0]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - m4_ifdef([gl_FUNC_STRERROR_R_WORKS], [ - AC_REQUIRE([gl_FUNC_STRERROR_R_WORKS]) - ]) - if test "$GL_GENERATE_ERRNO_H:$REPLACE_STRERROR_0" = false:0; then - AC_CACHE_CHECK([for working strerror function], - [gl_cv_func_working_strerror], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[if (!*strerror (-2)) return 1;]])], - [gl_cv_func_working_strerror=yes], - [gl_cv_func_working_strerror=no], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_working_strerror="guessing yes" ;; - # Guess yes on musl systems. - *-musl* | midipix*) gl_cv_func_working_strerror="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_working_strerror="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_working_strerror" in - *yes) ;; - *) - dnl The system's strerror() fails to return a string for out-of-range - dnl integers. Replace it. - REPLACE_STRERROR=1 - ;; - esac - m4_ifdef([gl_FUNC_STRERROR_R_WORKS], [ - dnl If the system's strerror_r or __xpg_strerror_r clobbers strerror's - dnl buffer, we must replace strerror. - case "$gl_cv_func_strerror_r_works" in - *no) REPLACE_STRERROR=1 ;; - esac - ]) - else - dnl The system's strerror() cannot know about the new errno values we add - dnl to , or any fix for strerror(0). Replace it. - REPLACE_STRERROR=1 - fi -]) -m4trace:gnulib-m4/strerror.m4:60: -1- AC_DEFUN([gl_FUNC_STRERROR_0], [ - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - REPLACE_STRERROR_0=0 - AC_CACHE_CHECK([whether strerror(0) succeeds], - [gl_cv_func_strerror_0_works], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - ]], - [[int result = 0; - char *str; - errno = 0; - str = strerror (0); - if (!*str) result |= 1; - if (errno) result |= 2; - if (strstr (str, "nknown") || strstr (str, "ndefined")) - result |= 4; - return result;]])], - [gl_cv_func_strerror_0_works=yes], - [gl_cv_func_strerror_0_works=no], - [case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_strerror_0_works="guessing yes" ;; - # Guess yes on musl systems. - *-musl* | midipix*) gl_cv_func_strerror_0_works="guessing yes" ;; - # Guess yes on native Windows. - mingw* | windows*) gl_cv_func_strerror_0_works="guessing yes" ;; - # If we don't know, obey --enable-cross-guesses. - *) gl_cv_func_strerror_0_works="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_strerror_0_works" in - *yes) ;; - *) - REPLACE_STRERROR_0=1 - AC_DEFINE([REPLACE_STRERROR_0], [1], [Define to 1 if strerror(0) - does not return a message implying success.]) - ;; - esac -]) -m4trace:gnulib-m4/string_h.m4:12: -1- AC_DEFUN_ONCE([gl_STRING_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - gl_NEXT_HEADERS([string.h]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use, and which is not - dnl guaranteed by C89. - gl_WARN_ON_USE_PREPARE([[#include - ]], - [explicit_bzero ffsl ffsll memmem mempcpy memrchr memset_explicit - rawmemchr stpcpy stpncpy strchrnul - strdup strncat strndup strnlen strpbrk strsep strcasestr strtok_r - strerror_r strerrorname_np sigabbrev_np sigdescr_np strsignal strverscmp]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/string_h.m4:36: -1- AC_DEFUN([gl_STRING_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_STRING_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/string_h.m4:48: -1- AC_DEFUN([gl_STRING_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_STRING_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXPLICIT_BZERO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFSL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFSLL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMMEM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMPCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMRCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMSET_EXPLICIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAWMEMCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STPCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STPNCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRCHRNUL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRDUP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNCAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNDUP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRPBRK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSEP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSTR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRCASESTR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOK_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSTR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCASECMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNCASECMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSPCASECMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCASESTR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCSPN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSPBRK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSPN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSEP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOK_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERROR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERROR_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERRORNAME_NP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGABBREV_NP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGDESCR_NP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSIGNAL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRVERSCMP]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MEMCCPY], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_STRDUP], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_STRING_H_MODULE_INDICATOR_DEFAULTS]) - dnl Make sure the shell variable for GNULIB_FREE_POSIX is initialized. - gl_STDLIB_H_REQUIRE_DEFAULTS - AC_REQUIRE([gl_STRING_H_DEFAULTS]) -]) -m4trace:gnulib-m4/string_h.m4:103: -1- AC_DEFUN([gl_STRING_H_DEFAULTS], [ - HAVE_MBSLEN=0; AC_SUBST([HAVE_MBSLEN]) - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_EXPLICIT_BZERO=1; AC_SUBST([HAVE_EXPLICIT_BZERO]) - HAVE_FFSL=1; AC_SUBST([HAVE_FFSL]) - HAVE_FFSLL=1; AC_SUBST([HAVE_FFSLL]) - HAVE_DECL_MEMMEM=1; AC_SUBST([HAVE_DECL_MEMMEM]) - HAVE_MEMPCPY=1; AC_SUBST([HAVE_MEMPCPY]) - HAVE_MEMSET_EXPLICIT=1; AC_SUBST([HAVE_MEMSET_EXPLICIT]) - HAVE_DECL_MEMRCHR=1; AC_SUBST([HAVE_DECL_MEMRCHR]) - HAVE_RAWMEMCHR=1; AC_SUBST([HAVE_RAWMEMCHR]) - HAVE_STPCPY=1; AC_SUBST([HAVE_STPCPY]) - HAVE_STPNCPY=1; AC_SUBST([HAVE_STPNCPY]) - HAVE_STRCHRNUL=1; AC_SUBST([HAVE_STRCHRNUL]) - HAVE_DECL_STRDUP=1; AC_SUBST([HAVE_DECL_STRDUP]) - HAVE_DECL_STRNDUP=1; AC_SUBST([HAVE_DECL_STRNDUP]) - HAVE_DECL_STRNLEN=1; AC_SUBST([HAVE_DECL_STRNLEN]) - HAVE_STRPBRK=1; AC_SUBST([HAVE_STRPBRK]) - HAVE_STRSEP=1; AC_SUBST([HAVE_STRSEP]) - HAVE_STRCASESTR=1; AC_SUBST([HAVE_STRCASESTR]) - HAVE_DECL_STRTOK_R=1; AC_SUBST([HAVE_DECL_STRTOK_R]) - HAVE_DECL_STRERROR_R=1; AC_SUBST([HAVE_DECL_STRERROR_R]) - HAVE_STRERRORNAME_NP=1; AC_SUBST([HAVE_STRERRORNAME_NP]) - HAVE_SIGABBREV_NP=1; AC_SUBST([HAVE_SIGABBREV_NP]) - HAVE_SIGDESCR_NP=1; AC_SUBST([HAVE_SIGDESCR_NP]) - HAVE_DECL_STRSIGNAL=1; AC_SUBST([HAVE_DECL_STRSIGNAL]) - HAVE_STRVERSCMP=1; AC_SUBST([HAVE_STRVERSCMP]) - REPLACE_FFSLL=0; AC_SUBST([REPLACE_FFSLL]) - REPLACE_MEMCHR=0; AC_SUBST([REPLACE_MEMCHR]) - REPLACE_MEMMEM=0; AC_SUBST([REPLACE_MEMMEM]) - REPLACE_MEMPCPY=0; AC_SUBST([REPLACE_MEMPCPY]) - REPLACE_MEMSET_EXPLICIT=0; AC_SUBST([REPLACE_MEMSET_EXPLICIT]) - REPLACE_STPCPY=0; AC_SUBST([REPLACE_STPCPY]) - REPLACE_STPNCPY=0; AC_SUBST([REPLACE_STPNCPY]) - REPLACE_STRCHRNUL=0; AC_SUBST([REPLACE_STRCHRNUL]) - REPLACE_STRDUP=0; AC_SUBST([REPLACE_STRDUP]) - REPLACE_STRNCAT=0; AC_SUBST([REPLACE_STRNCAT]) - REPLACE_STRNDUP=0; AC_SUBST([REPLACE_STRNDUP]) - REPLACE_STRNLEN=0; AC_SUBST([REPLACE_STRNLEN]) - REPLACE_STRSTR=0; AC_SUBST([REPLACE_STRSTR]) - REPLACE_STRCASESTR=0; AC_SUBST([REPLACE_STRCASESTR]) - REPLACE_STRTOK_R=0; AC_SUBST([REPLACE_STRTOK_R]) - REPLACE_STRERROR=0; AC_SUBST([REPLACE_STRERROR]) - REPLACE_STRERROR_R=0; AC_SUBST([REPLACE_STRERROR_R]) - REPLACE_STRERRORNAME_NP=0; AC_SUBST([REPLACE_STRERRORNAME_NP]) - REPLACE_STRSIGNAL=0; AC_SUBST([REPLACE_STRSIGNAL]) - REPLACE_STRVERSCMP=0; AC_SUBST([REPLACE_STRVERSCMP]) - UNDEFINE_STRTOK_R=0; AC_SUBST([UNDEFINE_STRTOK_R]) -]) -m4trace:gnulib-m4/strnlen.m4:8: -1- AC_DEFUN([gl_FUNC_STRNLEN], [ - AC_REQUIRE([gl_STRING_H_DEFAULTS]) - - dnl Persuade glibc to declare strnlen(). - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - AC_CHECK_DECLS_ONCE([strnlen]) - if test $ac_cv_have_decl_strnlen = no; then - HAVE_DECL_STRNLEN=0 - else - m4_pushdef([AC_LIBOBJ], [:]) - dnl Note: AC_FUNC_STRNLEN does AC_LIBOBJ([strnlen]). - AC_FUNC_STRNLEN - m4_popdef([AC_LIBOBJ]) - if test $ac_cv_func_strnlen_working = no; then - REPLACE_STRNLEN=1 - fi - fi -]) -m4trace:gnulib-m4/strnlen.m4:30: -1- AC_DEFUN([gl_PREREQ_STRNLEN], [:]) -m4trace:gnulib-m4/strtoul.m4:7: -1- AC_DEFUN([gl_FUNC_STRTOUL], [ - AC_REQUIRE([gl_STDLIB_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CHECK_FUNCS([strtoul]) - if test $ac_cv_func_strtoul = yes; then - AC_CACHE_CHECK([whether strtoul works], - [gl_cv_func_strtoul_works], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[int result = 0; - char *term; - /* This test fails on Minix and native Windows. */ - { - const char input[] = "0x"; - (void) strtoul (input, &term, 16); - if (term != input + 1) - result |= 1; - } - /* This test fails on pre-C23 platforms. */ - { - const char input[] = "0b1"; - (void) strtoul (input, &term, 2); - if (term != input + 3) - result |= 2; - } - return result; - ]]) - ], - [gl_cv_func_strtoul_works=yes], - [gl_cv_func_strtoul_works=no], - [case "$host_os" in - # Guess no on native Windows. - mingw* | windows*) gl_cv_func_strtoul_works="guessing no" ;; - # Guess no on glibc systems. - *-gnu* | gnu*) gl_cv_func_strtoul_works="guessing no" ;; - # Guess no on musl systems. - *-musl* | midipix*) gl_cv_func_strtoul_works="guessing no" ;; - *) gl_cv_func_strtoul_works="$gl_cross_guess_normal" ;; - esac - ]) - ]) - case "$gl_cv_func_strtoul_works" in - *yes) ;; - *) REPLACE_STRTOUL=1 ;; - esac - else - HAVE_STRTOUL=0 - fi -]) -m4trace:gnulib-m4/sys_socket_h.m4:9: -1- AC_DEFUN_ONCE([gl_SYS_SOCKET_H], [ - AC_REQUIRE([gl_SYS_SOCKET_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) - - dnl On OSF/1, the functions recv(), send(), recvfrom(), sendto() have - dnl old-style declarations (with return type 'int' instead of 'ssize_t') - dnl unless _POSIX_PII_SOCKET is defined. - case "$host_os" in - osf*) - AC_DEFINE([_POSIX_PII_SOCKET], [1], - [Define to 1 in order to get the POSIX compatible declarations - of socket functions.]) - ;; - esac - - GL_GENERATE_SYS_SOCKET_H=false - AC_CACHE_CHECK([whether is self-contained], - [gl_cv_header_sys_socket_h_selfcontained], - [ - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ]], [[]])], - [gl_cv_header_sys_socket_h_selfcontained=yes], - [gl_cv_header_sys_socket_h_selfcontained=no]) - ]) - if test $gl_cv_header_sys_socket_h_selfcontained = yes; then - dnl If the shutdown function exists, should define - dnl SHUT_RD, SHUT_WR, SHUT_RDWR. - AC_CHECK_FUNCS([shutdown]) - if test $ac_cv_func_shutdown = yes; then - AC_CACHE_CHECK([whether defines the SHUT_* macros], - [gl_cv_header_sys_socket_h_shut], - [ - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[#include ]], - [[int a[] = { SHUT_RD, SHUT_WR, SHUT_RDWR };]])], - [gl_cv_header_sys_socket_h_shut=yes], - [gl_cv_header_sys_socket_h_shut=no]) - ]) - if test $gl_cv_header_sys_socket_h_shut = no; then - GL_GENERATE_SYS_SOCKET_H=true - fi - fi - fi - # We need to check for ws2tcpip.h now. - gl_PREREQ_SYS_H_SOCKET - AC_CHECK_TYPES([struct sockaddr_storage, sa_family_t],,,[ - /* sys/types.h is not needed according to POSIX, but the - sys/socket.h in i386-unknown-freebsd4.10 and - powerpc-apple-darwin5.5 required it. */ -#include -#ifdef HAVE_SYS_SOCKET_H -#include -#endif -#ifdef HAVE_WS2TCPIP_H -#include -#endif -]) - if test $ac_cv_type_struct_sockaddr_storage = no; then - HAVE_STRUCT_SOCKADDR_STORAGE=0 - fi - if test $ac_cv_type_sa_family_t = no; then - HAVE_SA_FAMILY_T=0 - fi - if test $ac_cv_type_struct_sockaddr_storage != no; then - AC_CHECK_MEMBERS([struct sockaddr_storage.ss_family], - [], - [HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY=0], - [#include - #ifdef HAVE_SYS_SOCKET_H - #include - #endif - #ifdef HAVE_WS2TCPIP_H - #include - #endif - ]) - fi - if test $HAVE_STRUCT_SOCKADDR_STORAGE = 0 || test $HAVE_SA_FAMILY_T = 0 \ - || test $HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY = 0; then - GL_GENERATE_SYS_SOCKET_H=true - fi - gl_PREREQ_SYS_H_WINSOCK2 - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[ -/* Some systems require prerequisite headers. */ -#include -#include - ]], [socket connect accept bind getpeername getsockname getsockopt - listen recv send recvfrom sendto setsockopt shutdown accept4]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/sys_socket_h.m4:103: -1- AC_DEFUN([gl_PREREQ_SYS_H_SOCKET], [ - dnl Check prerequisites of the replacement. - AC_REQUIRE([gl_CHECK_SOCKET_HEADERS]) - gl_CHECK_NEXT_HEADERS([sys/socket.h]) - if test $ac_cv_header_sys_socket_h = yes; then - HAVE_SYS_SOCKET_H=1 - else - HAVE_SYS_SOCKET_H=0 - fi - AC_SUBST([HAVE_SYS_SOCKET_H]) - gl_PREREQ_SYS_H_WS2TCPIP -]) -m4trace:gnulib-m4/sys_socket_h.m4:120: -1- AC_DEFUN([gl_PREREQ_SYS_H_WINSOCK2], [ - m4_ifdef([gl_UNISTD_H_DEFAULTS], [AC_REQUIRE([gl_UNISTD_H_DEFAULTS])]) - m4_ifdef([gl_SYS_IOCTL_H_DEFAULTS], [AC_REQUIRE([gl_SYS_IOCTL_H_DEFAULTS])]) - AC_CHECK_HEADERS_ONCE([sys/socket.h]) - if test $ac_cv_header_sys_socket_h != yes; then - dnl We cannot use AC_CHECK_HEADERS_ONCE here, because that would make - dnl the check for those headers unconditional; yet cygwin reports - dnl that the headers are present but cannot be compiled (since on - dnl cygwin, all socket information should come from sys/socket.h). - AC_CHECK_HEADERS([winsock2.h]) - fi - if test "$ac_cv_header_winsock2_h" = yes; then - HAVE_WINSOCK2_H=1 - UNISTD_H_HAVE_WINSOCK2_H=1 - SYS_IOCTL_H_HAVE_WINSOCK2_H=1 - else - HAVE_WINSOCK2_H=0 - fi - AC_SUBST([HAVE_WINSOCK2_H]) -]) -m4trace:gnulib-m4/sys_socket_h.m4:145: -1- AC_DEFUN([gl_PREREQ_SYS_H_WS2TCPIP], [ - AC_REQUIRE([gl_CHECK_SOCKET_HEADERS]) - if test $ac_cv_header_sys_socket_h = yes; then - HAVE_WS2TCPIP_H=0 - else - if test $ac_cv_header_ws2tcpip_h = yes; then - HAVE_WS2TCPIP_H=1 - else - HAVE_WS2TCPIP_H=0 - fi - fi - AC_SUBST([HAVE_WS2TCPIP_H]) -]) -m4trace:gnulib-m4/sys_socket_h.m4:164: -1- AC_DEFUN([gl_SYS_SOCKET_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_SYS_SOCKET_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/sys_socket_h.m4:176: -1- AC_DEFUN([gl_SYS_SOCKET_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_SYS_SOCKET_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SOCKET]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CONNECT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ACCEPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_BIND]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPEERNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETSOCKNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETSOCKOPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LISTEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RECV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SEND]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RECVFROM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SENDTO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETSOCKOPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SHUTDOWN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ACCEPT4]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_SYS_SOCKET_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_SYS_SOCKET_H_DEFAULTS]) -]) -m4trace:gnulib-m4/sys_socket_h.m4:199: -1- AC_DEFUN([gl_SYS_SOCKET_H_DEFAULTS], [ - HAVE_STRUCT_SOCKADDR_STORAGE=1; AC_SUBST([HAVE_STRUCT_SOCKADDR_STORAGE]) - HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY=1; - AC_SUBST([HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY]) - HAVE_SA_FAMILY_T=1; AC_SUBST([HAVE_SA_FAMILY_T]) - HAVE_ACCEPT4=1; AC_SUBST([HAVE_ACCEPT4]) -]) -m4trace:gnulib-m4/sys_stat_h.m4:10: -1- AC_DEFUN_ONCE([gl_SYS_STAT_H], [ - AC_REQUIRE([gl_SYS_STAT_H_DEFAULTS]) - - dnl Check for broken stat macros. - AC_REQUIRE([AC_HEADER_STAT]) - - gl_CHECK_NEXT_HEADERS([sys/stat.h]) - - dnl Ensure the type mode_t gets defined. - AC_REQUIRE([AC_TYPE_MODE_T]) - - dnl Whether to enable precise timestamps in 'struct stat'. - m4_ifdef([gl_WINDOWS_STAT_TIMESPEC], [ - AC_REQUIRE([gl_WINDOWS_STAT_TIMESPEC]) - ], [ - WINDOWS_STAT_TIMESPEC=0 - ]) - AC_SUBST([WINDOWS_STAT_TIMESPEC]) - - dnl Whether to ensure that struct stat.st_size is 64-bit wide. - m4_ifdef([gl_LARGEFILE], [ - AC_REQUIRE([gl_LARGEFILE]) - ], [ - WINDOWS_64_BIT_ST_SIZE=0 - ]) - AC_SUBST([WINDOWS_64_BIT_ST_SIZE]) - - dnl Define types that are supposed to be defined in or - dnl . - AC_CHECK_TYPE([nlink_t], [], - [AC_DEFINE([nlink_t], [int], - [Define to the type of st_nlink in struct stat, or a supertype.])], - [#include - #include ]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[#include - ]], [chmod fchmodat fstat fstatat futimens getumask lchmod lstat - mkdirat mkfifo mkfifoat mknod mknodat stat utimensat]) - - AC_REQUIRE([AC_C_RESTRICT]) -]) -m4trace:gnulib-m4/sys_stat_h.m4:59: -1- AC_DEFUN([gl_SYS_STAT_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_SYS_STAT_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/sys_stat_h.m4:71: -1- AC_DEFUN([gl_SYS_STAT_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_SYS_STAT_H_MODULE_INDICATOR_DEFAULTS], [ - gl_UNISTD_H_REQUIRE_DEFAULTS dnl for REPLACE_FCHDIR - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHMOD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHMODAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSTAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSTATAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FUTIMENS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETUMASK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LCHMOD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LSTAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDIR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDIRAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKFIFO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKFIFOAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKNOD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKNODAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UTIMENSAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OVERRIDES_STRUCT_STAT]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CHMOD], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MKDIR], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_UMASK], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_SYS_STAT_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_SYS_STAT_H_DEFAULTS]) -]) -m4trace:gnulib-m4/sys_stat_h.m4:101: -1- AC_DEFUN([gl_SYS_STAT_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_FCHMODAT=1; AC_SUBST([HAVE_FCHMODAT]) - HAVE_FSTATAT=1; AC_SUBST([HAVE_FSTATAT]) - HAVE_FUTIMENS=1; AC_SUBST([HAVE_FUTIMENS]) - HAVE_GETUMASK=1; AC_SUBST([HAVE_GETUMASK]) - HAVE_LCHMOD=1; AC_SUBST([HAVE_LCHMOD]) - HAVE_LSTAT=1; AC_SUBST([HAVE_LSTAT]) - HAVE_MKDIRAT=1; AC_SUBST([HAVE_MKDIRAT]) - HAVE_MKFIFO=1; AC_SUBST([HAVE_MKFIFO]) - HAVE_MKFIFOAT=1; AC_SUBST([HAVE_MKFIFOAT]) - HAVE_MKNOD=1; AC_SUBST([HAVE_MKNOD]) - HAVE_MKNODAT=1; AC_SUBST([HAVE_MKNODAT]) - HAVE_UTIMENSAT=1; AC_SUBST([HAVE_UTIMENSAT]) - REPLACE_CHMOD=0; AC_SUBST([REPLACE_CHMOD]) - REPLACE_FCHMODAT=0; AC_SUBST([REPLACE_FCHMODAT]) - REPLACE_FSTAT=0; AC_SUBST([REPLACE_FSTAT]) - REPLACE_FSTATAT=0; AC_SUBST([REPLACE_FSTATAT]) - REPLACE_FUTIMENS=0; AC_SUBST([REPLACE_FUTIMENS]) - REPLACE_LSTAT=0; AC_SUBST([REPLACE_LSTAT]) - REPLACE_MKDIR=0; AC_SUBST([REPLACE_MKDIR]) - REPLACE_MKFIFO=0; AC_SUBST([REPLACE_MKFIFO]) - REPLACE_MKFIFOAT=0; AC_SUBST([REPLACE_MKFIFOAT]) - REPLACE_MKNOD=0; AC_SUBST([REPLACE_MKNOD]) - REPLACE_MKNODAT=0; AC_SUBST([REPLACE_MKNODAT]) - REPLACE_STAT=0; AC_SUBST([REPLACE_STAT]) - REPLACE_UTIMENSAT=0; AC_SUBST([REPLACE_UTIMENSAT]) -]) -m4trace:gnulib-m4/sys_types_h.m4:7: -1- AC_DEFUN_ONCE([gl_SYS_TYPES_H], [ - AC_REQUIRE([gl_SYS_TYPES_H_DEFAULTS]) - - dnl Use sane struct stat types in OpenVMS 8.2 and later. - AC_DEFINE([_USE_STD_STAT], 1, [For standard stat data types on VMS.]) - - gl_NEXT_HEADERS([sys/types.h]) - - dnl Ensure the type pid_t gets defined. - AC_REQUIRE([AC_TYPE_PID_T]) - - dnl Ensure the type mode_t gets defined. - AC_REQUIRE([AC_TYPE_MODE_T]) - - dnl Whether to override the 'off_t' type. - AC_REQUIRE([gl_TYPE_OFF_T]) - - dnl Whether to override the 'dev_t' and 'ino_t' types. - m4_ifdef([gl_WINDOWS_STAT_INODES], [ - AC_REQUIRE([gl_WINDOWS_STAT_INODES]) - ], [ - WINDOWS_STAT_INODES=0 - ]) - AC_SUBST([WINDOWS_STAT_INODES]) -]) -m4trace:gnulib-m4/sys_types_h.m4:37: -1- AC_DEFUN([gl_SYS_TYPES_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_SYS_TYPE_H_MODULE_INDICATOR_DEFAULTS], [ - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_SYS_TYPE_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_SYS_TYPES_H_DEFAULTS]) -]) -m4trace:gnulib-m4/sys_types_h.m4:45: -1- AC_DEFUN([gl_SYS_TYPES_H_DEFAULTS], [ -]) -m4trace:gnulib-m4/threadlib.m4:54: -1- AC_DEFUN([gl_ANYTHREADLIB_EARLY], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - if test -z "$gl_anythreadlib_early_done"; then - case "$host_os" in - osf*) - # On OSF/1, the compiler needs the flag -D_REENTRANT so that it - # groks . cc also understands the flag -pthread, but - # we don't use it because 1. gcc-2.95 doesn't understand -pthread, - # 2. putting a flag into CPPFLAGS that has an effect on the linker - # causes the AC_LINK_IFELSE test below to succeed unexpectedly, - # leading to wrong values of LIBTHREAD and LTLIBTHREAD. - CPPFLAGS="$CPPFLAGS -D_REENTRANT" - ;; - esac - # Some systems optimize for single-threaded programs by default, and - # need special flags to disable these optimizations. For example, the - # definition of 'errno' in . - case "$host_os" in - aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;; - solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; - esac - gl_anythreadlib_early_done=done - fi -]) -m4trace:gnulib-m4/threadlib.m4:82: -1- AC_DEFUN([gl_WEAK_SYMBOLS], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether imported symbols can be declared weak], - [gl_cv_have_weak], - [case "$host_os" in - cygwin* | mingw* | windows*) - dnl On Cygwin 3.2.0 with gcc 10.2, and likewise on mingw 10.0.0 with - dnl gcc 11.3, the test below would succeed, but programs that use - dnl pthread_in_use() with weak symbol references crash miserably at - dnl runtime. - gl_cv_have_weak="guessing no" - ;; - *) - gl_cv_have_weak=no - dnl First, test whether the compiler accepts it syntactically. - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[extern void xyzzy (); -#pragma weak xyzzy]], - [[xyzzy();]])], - [gl_cv_have_weak=maybe]) - if test $gl_cv_have_weak = maybe; then - dnl Second, test whether it actually works. On Cygwin 1.7.2, with - dnl gcc 4.3, symbols declared weak always evaluate to the address 0. - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#pragma weak fputs -int main () -{ - return (fputs == NULL); -}]])], - [gl_cv_have_weak=yes], - [gl_cv_have_weak=no], - [dnl When cross-compiling, assume that only ELF platforms support - dnl weak symbols. - AC_EGREP_CPP([Extensible Linking Format], - [#ifdef __ELF__ - Extensible Linking Format - #endif - ], - [gl_cv_have_weak="guessing yes"], - [gl_cv_have_weak="guessing no"]) - ]) - fi - ;; - esac - dnl But when linking statically, weak symbols don't work. - case " $LDFLAGS " in - *" -static "*) gl_cv_have_weak=no ;; - esac - dnl Test for a bug in FreeBSD 11: A link error occurs when using a weak - dnl symbol and linking against a shared library that has a dependency on - dnl the shared library that defines the symbol. - case "$gl_cv_have_weak" in - *yes) - case "$host_os" in - freebsd* | dragonfly* | midnightbsd*) - : > conftest1.c - $CC $CPPFLAGS $CFLAGS $LDFLAGS -fPIC -shared -o libempty.so conftest1.c -lpthread >&AS_MESSAGE_LOG_FD 2>&1 - cat < conftest2.c -#include -#pragma weak pthread_mutexattr_gettype -int main () -{ - return (pthread_mutexattr_gettype != NULL); -} -EOF - $CC $CPPFLAGS $CFLAGS $LDFLAGS -o conftest conftest2.c libempty.so >&AS_MESSAGE_LOG_FD 2>&1 \ - || gl_cv_have_weak=no - rm -f conftest1.c libempty.so conftest2.c conftest - ;; - esac - ;; - esac - ]) - case "$gl_cv_have_weak" in - *yes) - AC_DEFINE([HAVE_WEAK_SYMBOLS], [1], - [Define to 1 if the compiler and linker support weak declarations of symbols.]) - ;; - esac -]) -m4trace:gnulib-m4/threadlib.m4:187: -1- AC_DEFUN([gl_PTHREADLIB_BODY], [ - AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) - if test -z "$gl_pthreadlib_body_done"; then - gl_pthread_api=no - LIBPTHREAD= - LIBPMULTITHREAD= - # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that - # it groks . It's added above, in gl_ANYTHREADLIB_EARLY. - AC_CHECK_HEADER([pthread.h], - [gl_have_pthread_h=yes], [gl_have_pthread_h=no]) - if test "$gl_have_pthread_h" = yes; then - # Other possible tests: - # -lpthreads (FSU threads, PCthreads) - # -lgthreads - # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist - # in libc. IRIX 6.5 has the first one in both libc and libpthread, but - # the second one only in libpthread, and lock.c needs it. - # - # If -pthread works, prefer it to -lpthread, since Ubuntu 14.04 - # needs -pthread for some reason. See: - # https://lists.gnu.org/r/bug-gnulib/2014-09/msg00023.html - saved_LIBS="$LIBS" - for gl_pthread in '' '-pthread'; do - LIBS="$LIBS $gl_pthread" - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include - pthread_mutex_t m; - pthread_mutexattr_t ma; - ]], - [[pthread_mutex_lock (&m); - pthread_mutexattr_init (&ma);]])], - [gl_pthread_api=yes - LIBPTHREAD=$gl_pthread - LIBPMULTITHREAD=$gl_pthread]) - LIBS="$saved_LIBS" - test $gl_pthread_api = yes && break - done - echo "$as_me:__oline__: gl_pthread_api=$gl_pthread_api" >&AS_MESSAGE_LOG_FD - echo "$as_me:__oline__: LIBPTHREAD=$LIBPTHREAD" >&AS_MESSAGE_LOG_FD - - gl_pthread_in_glibc=no - # On Linux with glibc >= 2.34, libc contains the fully functional - # pthread functions. - case "$host_os" in - linux*) - AC_EGREP_CPP([Lucky user], - [#include - #ifdef __GNU_LIBRARY__ - #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 34) || (__GLIBC__ > 2) - Lucky user - #endif - #endif - ], - [gl_pthread_in_glibc=yes], - []) - ;; - esac - echo "$as_me:__oline__: gl_pthread_in_glibc=$gl_pthread_in_glibc" >&AS_MESSAGE_LOG_FD - - # Test for libpthread by looking for pthread_kill. (Not pthread_self, - # since it is defined as a macro on OSF/1.) - if test $gl_pthread_api = yes && test -z "$LIBPTHREAD"; then - # The program links fine without libpthread. But it may actually - # need to link with libpthread in order to create multiple threads. - AC_CHECK_LIB([pthread], [pthread_kill], - [if test $gl_pthread_in_glibc = yes; then - LIBPMULTITHREAD= - else - LIBPMULTITHREAD=-lpthread - # On Solaris and HP-UX, most pthread functions exist also in libc. - # Therefore pthread_in_use() needs to actually try to create a - # thread: pthread_create from libc will fail, whereas - # pthread_create will actually create a thread. - # On Solaris 10 or newer, this test is no longer needed, because - # libc contains the fully functional pthread functions. - case "$host_os" in -changequote(,)dnl - solaris | solaris2.[1-9] | solaris2.[1-9].* | hpux*) -changequote([,])dnl - AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], - [Define if the pthread_in_use() detection is hard.]) - esac - fi - ], - [dnl This is needed on FreeBSD 5.2.1. - AC_CHECK_LIB([thr], [pthread_kill], - [if test $gl_pthread_in_glibc = yes; then - LIBPMULTITHREAD= - else - LIBPMULTITHREAD=-lthr - fi - ]) - ]) - elif test $gl_pthread_api != yes; then - # Some library is needed. Try libpthread and libc_r. - AC_CHECK_LIB([pthread], [pthread_kill], - [gl_pthread_api=yes - LIBPTHREAD=-lpthread - LIBPMULTITHREAD=-lpthread]) - if test $gl_pthread_api != yes; then - # For FreeBSD 4. - AC_CHECK_LIB([c_r], [pthread_kill], - [gl_pthread_api=yes - LIBPTHREAD=-lc_r - LIBPMULTITHREAD=-lc_r]) - fi - fi - echo "$as_me:__oline__: LIBPMULTITHREAD=$LIBPMULTITHREAD" >&AS_MESSAGE_LOG_FD - fi - AC_MSG_CHECKING([whether POSIX threads API is available]) - AC_MSG_RESULT([$gl_pthread_api]) - AC_SUBST([LIBPTHREAD]) - AC_SUBST([LIBPMULTITHREAD]) - if test $gl_pthread_api = yes; then - AC_DEFINE([HAVE_PTHREAD_API], [1], - [Define if you have the header and the POSIX threads API.]) - fi - - dnl On some systems, sched_yield is in librt, rather than in libpthread. - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[sched_yield ();]])], - [SCHED_YIELD_LIB= - ], - [dnl Solaris 7...10 has sched_yield in librt, not in libpthread or libc. - AC_CHECK_LIB([rt], [sched_yield], [SCHED_YIELD_LIB=-lrt], - [dnl Solaris 2.5.1, 2.6 has sched_yield in libposix4, not librt. - AC_CHECK_LIB([posix4], [sched_yield], [SCHED_YIELD_LIB=-lposix4])]) - ]) - AC_SUBST([SCHED_YIELD_LIB]) - dnl For backward compatibility. - LIB_SCHED_YIELD="$SCHED_YIELD_LIB" - AC_SUBST([LIB_SCHED_YIELD]) - - gl_pthreadlib_body_done=done - fi -]) -m4trace:gnulib-m4/threadlib.m4:328: -1- AC_DEFUN([gl_PTHREADLIB], [ - AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) - gl_PTHREADLIB_BODY -]) -m4trace:gnulib-m4/threadlib.m4:348: -1- AC_DEFUN([gl_STDTHREADLIB_BODY], [ - AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) - AC_REQUIRE([AC_CANONICAL_HOST]) - if test -z "$gl_stdthreadlib_body_done"; then - AC_CHECK_HEADERS_ONCE([threads.h]) - - case "$host_os" in - mingw* | windows*) - LIBSTDTHREAD= - ;; - *) - gl_PTHREADLIB_BODY - if test $ac_cv_header_threads_h = yes; then - dnl glibc >= 2.29 has thrd_create in libpthread. - dnl FreeBSD >= 10 has thrd_create in libstdthreads; this library depends - dnl on libpthread (for the symbol 'pthread_mutexattr_gettype'). - dnl glibc >= 2.34, AIX >= 7.1, and Solaris >= 11.4 have thrd_create in - dnl libc. - gl_CHECK_FUNCS_ANDROID([thrd_create], [[#include ]]) - if test $ac_cv_func_thrd_create = yes; then - LIBSTDTHREAD= - else - AC_CHECK_LIB([stdthreads], [thrd_create], [ - LIBSTDTHREAD='-lstdthreads -lpthread' - ], [ - dnl Guess that thrd_create is in libpthread. - LIBSTDTHREAD="$LIBPMULTITHREAD" - ]) - fi - else - dnl Libraries needed by thrd.c, mtx.c, cnd.c, tss.c. - LIBSTDTHREAD="$LIBPMULTITHREAD $SCHED_YIELD_LIB" - fi - ;; - esac - AC_SUBST([LIBSTDTHREAD]) - - AC_MSG_CHECKING([whether ISO C threads API is available]) - AC_MSG_RESULT([$ac_cv_header_threads_h]) - gl_stdthreadlib_body_done=done - fi -]) -m4trace:gnulib-m4/threadlib.m4:392: -1- AC_DEFUN([gl_STDTHREADLIB], [ - AC_REQUIRE([gl_ANYTHREADLIB_EARLY]) - gl_STDTHREADLIB_BODY -]) -m4trace:gnulib-m4/threadlib.m4:429: -1- AC_DEFUN([gl_THREADLIB_EARLY], [ - AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) -]) -m4trace:gnulib-m4/threadlib.m4:436: -1- AC_DEFUN([gl_THREADLIB_EARLY_BODY], [ - dnl Ordering constraints: This macro modifies CPPFLAGS in a way that - dnl influences the result of the autoconf tests that test for *_unlocked - dnl declarations, on AIX 5 at least. Therefore it must come early. - AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl - AC_BEFORE([$0], [gl_ARGP])dnl - - AC_REQUIRE([AC_CANONICAL_HOST]) - dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - dnl Check for multithreading. - m4_ifdef([gl_THREADLIB_DEFAULT_NO], - [m4_divert_text([DEFAULTS], [gl_use_threads_default=no])], - [m4_divert_text([DEFAULTS], [gl_use_threads_default=])]) - dnl gl_use_winpthreads_default defaults to 'no', because in mingw 10, like - dnl in mingw 5, the use of libwinpthread still makes test-pthread-tss crash. - m4_divert_text([DEFAULTS], [gl_use_winpthreads_default=no]) - AC_ARG_ENABLE([threads], -AS_HELP_STRING([[--enable-threads={isoc|posix|isoc+posix|windows}]], [specify multithreading API])m4_ifdef([gl_THREADLIB_DEFAULT_NO], [], [ -AS_HELP_STRING([[--disable-threads]], [build without multithread safety])]), - [gl_use_threads=$enableval], - [if test -n "$gl_use_threads_default"; then - gl_use_threads="$gl_use_threads_default" - else -changequote(,)dnl - case "$host_os" in - dnl Disable multithreading by default on OSF/1, because it interferes - dnl with fork()/exec(): When msgexec is linked with -lpthread, its - dnl child process gets an endless segmentation fault inside execvp(). - osf*) gl_use_threads=no ;; - dnl Disable multithreading by default on Cygwin 1.5.x, because it has - dnl bugs that lead to endless loops or crashes. See - dnl . - cygwin*) - case `uname -r` in - 1.[0-5].*) gl_use_threads=no ;; - *) gl_use_threads=yes ;; - esac - ;; - dnl Obey gl_AVOID_WINPTHREAD on mingw. - mingw* | windows*) - case "$gl_use_winpthreads_default" in - yes) gl_use_threads=posix ;; - no) gl_use_threads=windows ;; - *) gl_use_threads=yes ;; - esac - ;; - *) gl_use_threads=yes ;; - esac -changequote([,])dnl - fi - ]) - if test "$gl_use_threads" = yes \ - || test "$gl_use_threads" = isoc \ - || test "$gl_use_threads" = posix \ - || test "$gl_use_threads" = isoc+posix; then - # For using or : - gl_ANYTHREADLIB_EARLY - fi -]) -m4trace:gnulib-m4/threadlib.m4:500: -1- AC_DEFUN([gl_THREADLIB_BODY], [ - AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) - gl_threads_api=none - LIBTHREAD= - LTLIBTHREAD= - LIBMULTITHREAD= - LTLIBMULTITHREAD= - if test "$gl_use_threads" != no; then - dnl Check whether the compiler and linker support weak declarations. - gl_WEAK_SYMBOLS - if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then - dnl If we use weak symbols to implement pthread_in_use / pth_in_use / - dnl thread_in_use, we also need to test whether the ISO C 11 thrd_create - dnl facility is in use. - AC_CHECK_HEADERS_ONCE([threads.h]) - : - fi - if test "$gl_use_threads" = isoc || test "$gl_use_threads" = isoc+posix; then - AC_CHECK_HEADERS_ONCE([threads.h]) - gl_have_isoc_threads="$ac_cv_header_threads_h" - fi - if test "$gl_use_threads" = yes \ - || test "$gl_use_threads" = posix \ - || test "$gl_use_threads" = isoc+posix; then - gl_PTHREADLIB_BODY - LIBTHREAD=$LIBPTHREAD LTLIBTHREAD=$LIBPTHREAD - LIBMULTITHREAD=$LIBPMULTITHREAD LTLIBMULTITHREAD=$LIBPMULTITHREAD - if test $gl_pthread_api = yes; then - if test "$gl_use_threads" = isoc+posix && test "$gl_have_isoc_threads" = yes; then - gl_threads_api='isoc+posix' - AC_DEFINE([USE_ISOC_AND_POSIX_THREADS], [1], - [Define if the combination of the ISO C and POSIX multithreading APIs can be used.]) - LIBTHREAD= LTLIBTHREAD= - else - gl_threads_api=posix - AC_DEFINE([USE_POSIX_THREADS], [1], - [Define if the POSIX multithreading library can be used.]) - if test -z "$LIBMULTITHREAD" && test -z "$LTLIBMULTITHREAD"; then - AC_DEFINE([USE_POSIX_THREADS_FROM_LIBC], [1], - [Define if references to the POSIX multithreading library are satisfied by libc.]) - else - if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then - AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], - [Define if references to the POSIX multithreading library should be made weak.]) - LIBTHREAD= LTLIBTHREAD= - else - case "$host_os" in - freebsd* | dragonfly* | midnightbsd*) - if test "x$LIBTHREAD" != "x$LIBMULTITHREAD"; then - dnl If weak symbols can't tell whether pthread_create(), pthread_key_create() - dnl etc. will succeed, we need a runtime test. - AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], - [Define if the pthread_in_use() detection is hard.]) - fi - ;; - esac - fi - fi - fi - fi - fi - if test $gl_threads_api = none; then - if test "$gl_use_threads" = isoc && test "$gl_have_isoc_threads" = yes; then - gl_STDTHREADLIB_BODY - LIBTHREAD=$LIBSTDTHREAD LTLIBTHREAD=$LIBSTDTHREAD - LIBMULTITHREAD=$LIBSTDTHREAD LTLIBMULTITHREAD=$LIBSTDTHREAD - gl_threads_api=isoc - AC_DEFINE([USE_ISOC_THREADS], [1], - [Define if the ISO C multithreading library can be used.]) - fi - fi - if test $gl_threads_api = none; then - case "$gl_use_threads" in - yes | windows | win32) # The 'win32' is for backward compatibility. - if { case "$host_os" in - mingw* | windows*) true;; - *) false;; - esac - }; then - gl_threads_api=windows - AC_DEFINE([USE_WINDOWS_THREADS], [1], - [Define if the native Windows multithreading API can be used.]) - fi - ;; - esac - fi - else - dnl "$gl_use_threads" is "no". - AC_DEFINE([AVOID_ANY_THREADS], [1], - [Define if no multithread safety and no multithreading is desired.]) - fi - AC_MSG_CHECKING([for multithread API to use]) - AC_MSG_RESULT([$gl_threads_api]) - AC_SUBST([LIBTHREAD]) - AC_SUBST([LTLIBTHREAD]) - AC_SUBST([LIBMULTITHREAD]) - AC_SUBST([LTLIBMULTITHREAD]) -]) -m4trace:gnulib-m4/threadlib.m4:600: -1- AC_DEFUN([gl_THREADLIB], [ - AC_REQUIRE([gl_THREADLIB_EARLY]) - AC_REQUIRE([gl_THREADLIB_BODY]) -]) -m4trace:gnulib-m4/threadlib.m4:613: -1- AC_DEFUN([gl_DISABLE_THREADS], [ - m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no]) -]) -m4trace:gnulib-m4/threadlib.m4:626: -1- AC_DEFUN([gl_AVOID_WINPTHREAD], [ - m4_divert_text([INIT_PREPARE], [gl_use_winpthreads_default=no]) -]) -m4trace:gnulib-m4/time_h.m4:13: -1- AC_DEFUN_ONCE([gl_TIME_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_TIME_H_DEFAULTS]) - - gl_NEXT_HEADERS([time.h]) - AC_REQUIRE([gl_CHECK_TYPE_STRUCT_TIMESPEC]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[ -#include - ]], [ - asctime asctime_r ctime ctime_r gmtime_r localtime localtime_r mktime - nanosleep strftime strptime time timegm timespec_get timespec_getres tzset - ]) - - AC_REQUIRE([AC_C_RESTRICT]) - - AC_CACHE_CHECK([for TIME_UTC in ], - [gl_cv_time_h_has_TIME_UTC], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[static int x = TIME_UTC; x++;]])], - [gl_cv_time_h_has_TIME_UTC=yes], - [gl_cv_time_h_has_TIME_UTC=no])]) - if test $gl_cv_time_h_has_TIME_UTC = yes; then - TIME_H_DEFINES_TIME_UTC=1 - else - TIME_H_DEFINES_TIME_UTC=0 - fi - AC_SUBST([TIME_H_DEFINES_TIME_UTC]) -]) -m4trace:gnulib-m4/time_h.m4:53: -1- AC_DEFUN([gl_CHECK_TYPE_STRUCT_TIMESPEC], [ - AC_CHECK_HEADERS_ONCE([sys/time.h]) - AC_CACHE_CHECK([for struct timespec in ], - [gl_cv_sys_struct_timespec_in_time_h], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[static struct timespec x; x.tv_sec = x.tv_nsec;]])], - [gl_cv_sys_struct_timespec_in_time_h=yes], - [gl_cv_sys_struct_timespec_in_time_h=no])]) - - TIME_H_DEFINES_STRUCT_TIMESPEC=0 - SYS_TIME_H_DEFINES_STRUCT_TIMESPEC=0 - PTHREAD_H_DEFINES_STRUCT_TIMESPEC=0 - UNISTD_H_DEFINES_STRUCT_TIMESPEC=0 - if test $gl_cv_sys_struct_timespec_in_time_h = yes; then - TIME_H_DEFINES_STRUCT_TIMESPEC=1 - else - AC_CACHE_CHECK([for struct timespec in ], - [gl_cv_sys_struct_timespec_in_sys_time_h], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[static struct timespec x; x.tv_sec = x.tv_nsec;]])], - [gl_cv_sys_struct_timespec_in_sys_time_h=yes], - [gl_cv_sys_struct_timespec_in_sys_time_h=no])]) - if test $gl_cv_sys_struct_timespec_in_sys_time_h = yes; then - SYS_TIME_H_DEFINES_STRUCT_TIMESPEC=1 - else - AC_CACHE_CHECK([for struct timespec in ], - [gl_cv_sys_struct_timespec_in_pthread_h], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[static struct timespec x; x.tv_sec = x.tv_nsec;]])], - [gl_cv_sys_struct_timespec_in_pthread_h=yes], - [gl_cv_sys_struct_timespec_in_pthread_h=no])]) - if test $gl_cv_sys_struct_timespec_in_pthread_h = yes; then - PTHREAD_H_DEFINES_STRUCT_TIMESPEC=1 - else - AC_CACHE_CHECK([for struct timespec in ], - [gl_cv_sys_struct_timespec_in_unistd_h], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[static struct timespec x; x.tv_sec = x.tv_nsec;]])], - [gl_cv_sys_struct_timespec_in_unistd_h=yes], - [gl_cv_sys_struct_timespec_in_unistd_h=no])]) - if test $gl_cv_sys_struct_timespec_in_unistd_h = yes; then - UNISTD_H_DEFINES_STRUCT_TIMESPEC=1 - fi - fi - fi - fi - AC_SUBST([TIME_H_DEFINES_STRUCT_TIMESPEC]) - AC_SUBST([SYS_TIME_H_DEFINES_STRUCT_TIMESPEC]) - AC_SUBST([PTHREAD_H_DEFINES_STRUCT_TIMESPEC]) - AC_SUBST([UNISTD_H_DEFINES_STRUCT_TIMESPEC]) -]) -m4trace:gnulib-m4/time_h.m4:122: -1- AC_DEFUN([gl_TIME_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_TIME_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/time_h.m4:134: -1- AC_DEFUN([gl_TIME_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_TIME_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NANOSLEEP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRFTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRPTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMEGM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMESPEC_GET]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMESPEC_GETRES]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME_RZ]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TZSET]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_TZSET], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_TIME_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_TIME_H_DEFAULTS]) -]) -m4trace:gnulib-m4/time_h.m4:157: -1- AC_DEFUN([gl_TIME_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_DECL_LOCALTIME_R=1; AC_SUBST([HAVE_DECL_LOCALTIME_R]) - HAVE_NANOSLEEP=1; AC_SUBST([HAVE_NANOSLEEP]) - HAVE_STRPTIME=1; AC_SUBST([HAVE_STRPTIME]) - HAVE_TIMEGM=1; AC_SUBST([HAVE_TIMEGM]) - HAVE_TIMESPEC_GET=1; AC_SUBST([HAVE_TIMESPEC_GET]) - HAVE_TIMESPEC_GETRES=1; AC_SUBST([HAVE_TIMESPEC_GETRES]) - dnl Even GNU libc does not have timezone_t yet. - HAVE_TIMEZONE_T=0; AC_SUBST([HAVE_TIMEZONE_T]) - REPLACE_CTIME=0; AC_SUBST([REPLACE_CTIME]) - REPLACE_GMTIME=0; AC_SUBST([REPLACE_GMTIME]) - REPLACE_LOCALTIME=0; AC_SUBST([REPLACE_LOCALTIME]) - REPLACE_LOCALTIME_R=0; AC_SUBST([REPLACE_LOCALTIME_R]) - REPLACE_MKTIME=0; AC_SUBST([REPLACE_MKTIME]) - REPLACE_NANOSLEEP=0; AC_SUBST([REPLACE_NANOSLEEP]) - REPLACE_STRFTIME=0; AC_SUBST([REPLACE_STRFTIME]) - REPLACE_TIME=0; AC_SUBST([REPLACE_TIME]) - REPLACE_TIMEGM=0; AC_SUBST([REPLACE_TIMEGM]) - REPLACE_TIMESPEC_GET=0; AC_SUBST([REPLACE_TIMESPEC_GET]) - REPLACE_TIMESPEC_GETRES=0; AC_SUBST([REPLACE_TIMESPEC_GETRES]) - REPLACE_TZSET=0; AC_SUBST([REPLACE_TZSET]) -]) -m4trace:gnulib-m4/uchar_h.m4:10: -1- AC_DEFUN_ONCE([gl_UCHAR_H], [ - AC_REQUIRE([gl_UCHAR_H_DEFAULTS]) - - gl_CHECK_NEXT_HEADERS([uchar.h]) - if test $ac_cv_header_uchar_h = yes; then - HAVE_UCHAR_H=1 - else - HAVE_UCHAR_H=0 - fi - AC_SUBST([HAVE_UCHAR_H]) - - gl_TYPE_CHAR8_T - gl_TYPE_CHAR16_T - gl_TYPE_CHAR32_T - - dnl In C++ mode, clang defines 'char16_t' and 'char32_t' as built-in types - dnl on some platforms (e.g. OpenBSD 6.7), and as types defined by many - dnl header files (, , , , - dnl and others) on some platforms (e.g. Mac OS X 10.13). - dnl The same thing may also happen for 'char8_t'; so, be prepared for it. - m4_ifdef([gl_ANSI_CXX], [AC_REQUIRE([gl_ANSI_CXX])]) - CXX_HAS_UCHAR_TYPES=0 - if test $HAVE_UCHAR_H = 0; then - if test "$CXX" != no; then - AC_CACHE_CHECK([whether the C++ compiler predefines the types], - [gl_cv_cxx_has_uchar_types], - [dnl We can't use AC_LANG_PUSH([C++]) and AC_LANG_POP([C++]) here, due to - dnl an autoconf bug . - cat > conftest.cpp <<\EOF -#include -char16_t a; -char32_t b; -EOF - gl_command="$CXX $CXXFLAGS $CPPFLAGS -c conftest.cpp" - if AC_TRY_EVAL([gl_command]); then - gl_cv_cxx_has_uchar_types=yes - else - gl_cv_cxx_has_uchar_types=no - fi - rm -fr conftest* - ]) - if test $gl_cv_cxx_has_uchar_types = yes; then - CXX_HAS_UCHAR_TYPES=1 - fi - fi - fi - AC_SUBST([CXX_HAS_UCHAR_TYPES]) - CXX_HAS_CHAR8_TYPE=0 - if test $HAVE_UCHAR_H = 0; then - if test "$CXX" != no; then - AC_CACHE_CHECK([whether the C++ compiler predefines the char8_t types], - [gl_cv_cxx_has_char8_type], - [dnl We can't use AC_LANG_PUSH([C++]) and AC_LANG_POP([C++]) here, due to - dnl an autoconf bug . - cat > conftest.cpp <<\EOF -#include -char8_t a; -EOF - gl_command="$CXX $CXXFLAGS $CPPFLAGS -c conftest.cpp" - if AC_TRY_EVAL([gl_command]); then - gl_cv_cxx_has_char8_type=yes - else - gl_cv_cxx_has_char8_type=no - fi - rm -fr conftest* - ]) - if test $gl_cv_cxx_has_char8_type = yes; then - CXX_HAS_CHAR8_TYPE=1 - fi - fi - fi - AC_SUBST([CXX_HAS_CHAR8_TYPE]) - - dnl Test whether a 'char32_t' can hold more characters than a 'wchar_t'. - gl_STDINT_BITSIZEOF([wchar_t], [gl_STDINT_INCLUDES]) - if test $BITSIZEOF_WCHAR_T -lt 32; then - SMALL_WCHAR_T=1 - else - SMALL_WCHAR_T=0 - fi - dnl SMALL_WCHAR_T is expected to be 1 on 32-bit AIX, Cygwin, native Windows. - AC_SUBST([SMALL_WCHAR_T]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use, and which is not - dnl guaranteed by C11. - gl_WARN_ON_USE_PREPARE([[ - #ifdef __HAIKU__ - #include - #endif - #include - ]], [c32rtomb mbrtoc16 mbrtoc32]) -]) -m4trace:gnulib-m4/uchar_h.m4:105: -1- AC_DEFUN_ONCE([gl_TYPE_CHAR8_T], [ - dnl Determine whether gnulib's would, if present, override char8_t. - AC_CACHE_CHECK([whether char8_t is correctly defined], - [gl_cv_type_char8_t_works], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #ifdef __HAIKU__ - #include - #endif - #include - int verify[(char8_t)(-1) >= 0 && sizeof (char8_t) == sizeof (unsigned char) ? 1 : -1]; - ]]) - ], - [gl_cv_type_char8_t_works=yes], - [gl_cv_type_char8_t_works=no]) - ]) - if test $gl_cv_type_char8_t_works = no; then - GNULIBHEADERS_OVERRIDE_CHAR8_T=1 - else - GNULIBHEADERS_OVERRIDE_CHAR8_T=0 - fi - AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR8_T]) -]) -m4trace:gnulib-m4/uchar_h.m4:132: -1- AC_DEFUN_ONCE([gl_TYPE_CHAR16_T], [ - dnl Determine whether gnulib's would, if present, override char16_t. - AC_CACHE_CHECK([whether char16_t is correctly defined], - [gl_cv_type_char16_t_works], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #ifdef __HAIKU__ - #include - #endif - #include - /* For simplicity, assume that uint16_least_t is equivalent to - 'unsigned short'. */ - int verify[(char16_t)(-1) >= 0 && sizeof (char16_t) == sizeof (unsigned short) ? 1 : -1]; - ]]) - ], - [gl_cv_type_char16_t_works=yes], - [gl_cv_type_char16_t_works=no]) - ]) - if test $gl_cv_type_char16_t_works = no; then - GNULIBHEADERS_OVERRIDE_CHAR16_T=1 - else - GNULIBHEADERS_OVERRIDE_CHAR16_T=0 - fi - AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR16_T]) -]) -m4trace:gnulib-m4/uchar_h.m4:158: -1- AC_DEFUN_ONCE([gl_TYPE_CHAR32_T], [ - dnl Determine whether gnulib's would, if present, override char32_t. - AC_CACHE_CHECK([whether char32_t is correctly defined], - [gl_cv_type_char32_t_works], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[ - #ifdef __HAIKU__ - #include - #endif - #include - /* For simplicity, assume that uint32_least_t is equivalent to - 'unsigned int'. */ - int verify[(char32_t)(-1) >= 0 && sizeof (char32_t) == sizeof (unsigned int) ? 1 : -1]; - ]]) - ], - [gl_cv_type_char32_t_works=yes], - [gl_cv_type_char32_t_works=no]) - ]) - if test $gl_cv_type_char32_t_works = no; then - GNULIBHEADERS_OVERRIDE_CHAR32_T=1 - else - GNULIBHEADERS_OVERRIDE_CHAR32_T=0 - fi - AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR32_T]) -]) -m4trace:gnulib-m4/uchar_h.m4:189: -1- AC_DEFUN([gl_UCHAR_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_UCHAR_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/uchar_h.m4:201: -1- AC_DEFUN([gl_UCHAR_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_UCHAR_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_BTOC32]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISALNUM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISALPHA]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISBLANK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISCNTRL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISDIGIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISGRAPH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISLOWER]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISPRINT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISPUNCT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISSPACE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISUPPER]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISXDIGIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOLOWER]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOUPPER]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32WIDTH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32RTOMB]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SNRTOMBS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SRTOMBS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32STOMBS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SWIDTH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOB]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_APPLY_MAPPING]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_APPLY_TYPE_TEST]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_GET_MAPPING]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_GET_TYPE_TEST]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOC16]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOC32]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNRTOC32S]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRTOC32S]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOC32S]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_UCHAR_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_UCHAR_H_DEFAULTS]) -]) -m4trace:gnulib-m4/uchar_h.m4:240: -1- AC_DEFUN([gl_UCHAR_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_C32RTOMB=1; AC_SUBST([HAVE_C32RTOMB]) - HAVE_MBRTOC16=1; AC_SUBST([HAVE_MBRTOC16]) - HAVE_MBRTOC32=1; AC_SUBST([HAVE_MBRTOC32]) - REPLACE_C32RTOMB=0; AC_SUBST([REPLACE_C32RTOMB]) - REPLACE_MBRTOC16=0; AC_SUBST([REPLACE_MBRTOC16]) - REPLACE_MBRTOC32=0; AC_SUBST([REPLACE_MBRTOC32]) -]) -m4trace:gnulib-m4/unicase_h.m4:7: -1- AC_DEFUN_ONCE([gl_UNICASE_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_UNICASE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/unicase_h.m4:18: -1- AC_DEFUN([gl_UNICASE_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_UNICASE_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/unicase_h.m4:30: -1- AC_DEFUN([gl_UNICASE_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_UNICASE_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICASE_EMPTY_PREFIX_CONTEXT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICASE_EMPTY_SUFFIX_CONTEXT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_UNICASE_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_UNICASE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/unicase_h.m4:40: -1- AC_DEFUN([gl_UNICASE_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. -]) -m4trace:gnulib-m4/unictype_h.m4:7: -1- AC_DEFUN_ONCE([gl_UNICTYPE_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_UNICTYPE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/unictype_h.m4:18: -1- AC_DEFUN([gl_UNICTYPE_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_UNICTYPE_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/unictype_h.m4:30: -1- AC_DEFUN([gl_UNICTYPE_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_UNICTYPE_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_L_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LU_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LM_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_M_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_MN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_MC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ME_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_N_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_NL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_NO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_P_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PI_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_S_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SM_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_Z_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZP_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_C_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_WHITE_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ALPHABETIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ALPHABETIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NOT_A_CHARACTER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DEPRECATED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LOGICAL_ORDER_EXCEPTION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_VARIATION_SELECTOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PRIVATE_USE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UNASSIGNED_CODE_VALUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UPPERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_UPPERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LOWERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_LOWERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_TITLECASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CASE_IGNORABLE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_LOWERCASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_UPPERCASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_TITLECASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEFOLDED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEMAPPED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SOFT_DOTTED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_XID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_XID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PATTERN_WHITE_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PATTERN_SYNTAX_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_JOIN_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_BASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_EXTEND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_GRAPHEME_EXTEND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_LINK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_LEFT_TO_RIGHT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUROPEAN_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_TERMINATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_COMMON_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_BLOCK_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_SEGMENT_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_WHITESPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_NON_SPACING_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_BOUNDARY_NEUTRAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_PDF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_OTHER_NEUTRAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_HEX_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ASCII_HEX_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDEOGRAPHIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UNIFIED_IDEOGRAPH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_RADICAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_UNARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_BINARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_TRINARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_PRESENTATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_BASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_COMPONENT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EXTENDED_PICTOGRAPHIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ZERO_WIDTH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NON_BREAK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ISO_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_FORMAT_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PREPENDED_CONCATENATION_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DASH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_HYPHEN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LINE_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PARAGRAPH_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_QUOTATION_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SENTENCE_TERMINAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_TERMINAL_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CURRENCY_SYMBOL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_MATH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_MATH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PAIRED_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LEFT_OF_PAIR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_COMBINING_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_COMPOSITE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DECIMAL_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NUMERIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DIACRITIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EXTENDER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IGNORABLE_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_REGIONAL_INDICATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_UNICTYPE_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_UNICTYPE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/unictype_h.m4:173: -1- AC_DEFUN([gl_UNICTYPE_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. -]) -m4trace:gnulib-m4/uninorm_h.m4:7: -1- AC_DEFUN_ONCE([gl_UNINORM_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_UNINORM_H_DEFAULTS]) -]) -m4trace:gnulib-m4/uninorm_h.m4:18: -1- AC_DEFUN([gl_UNINORM_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_UNINORM_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/uninorm_h.m4:30: -1- AC_DEFUN([gl_UNINORM_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_UNINORM_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFKD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFKC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_UNINORM_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_UNINORM_H_DEFAULTS]) -]) -m4trace:gnulib-m4/uninorm_h.m4:42: -1- AC_DEFUN([gl_UNINORM_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. -]) -m4trace:gnulib-m4/unistd_h.m4:9: -1- AC_DEFUN_ONCE([gl_UNISTD_H], [ - dnl Ensure to expand the default settings once only, before all statements - dnl that occur in other macros. - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) - - gl_CHECK_NEXT_HEADERS([unistd.h]) - if test $ac_cv_header_unistd_h = yes; then - HAVE_UNISTD_H=1 - else - HAVE_UNISTD_H=0 - fi - AC_SUBST([HAVE_UNISTD_H]) - - dnl Ensure the type pid_t gets defined. - AC_REQUIRE([AC_TYPE_PID_T]) - - dnl Determine WINDOWS_64_BIT_OFF_T. - AC_REQUIRE([gl_TYPE_OFF_T]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[ -#if HAVE_UNISTD_H -# include -#endif -/* Some systems declare various items in the wrong headers. */ -#if !(defined __GLIBC__ && !defined __UCLIBC__) -# include -# include -# include -# if defined _WIN32 && ! defined __CYGWIN__ -# include -# endif -#endif - ]], [access chdir chown copy_file_range dup dup2 dup3 environ euidaccess - execl execle execlp execv execve execvp execvpe - faccessat fchdir - fchownat fdatasync fsync ftruncate getcwd getdomainname getdtablesize - getentropy getgroups gethostname getlogin getlogin_r getpagesize getpass - getusershell setusershell endusershell - group_member isatty lchown link linkat lseek pipe pipe2 pread pwrite - readlink readlinkat rmdir sethostname sleep symlink symlinkat - truncate ttyname_r unlink unlinkat usleep]) - - AC_REQUIRE([AC_C_RESTRICT]) - - AC_CHECK_DECLS_ONCE([execvpe]) - if test $ac_cv_have_decl_execvpe = no; then - HAVE_DECL_EXECVPE=0 - fi -]) -m4trace:gnulib-m4/unistd_h.m4:66: -1- AC_DEFUN([gl_UNISTD_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_UNISTD_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/unistd_h.m4:78: -1- AC_DEFUN([gl_UNISTD_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_UNISTD_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ACCESS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHDIR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHOWN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CLOSE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_COPY_FILE_RANGE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP2]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP3]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ENVIRON]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EUIDACCESS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECLE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECLP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECV]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FACCESSAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHDIR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHOWNAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FDATASYNC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSYNC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTRUNCATE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETCWD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDOMAINNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDTABLESIZE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETENTROPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETGROUPS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETHOSTNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOGIN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOGIN_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETOPT_POSIX]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPAGESIZE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPASS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPASS_GNU]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETUSERSHELL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GROUP_MEMBER]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISATTY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LCHOWN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LINK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LINKAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LSEEK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PIPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PIPE2]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PREAD]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PWRITE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READ]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READLINK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READLINKAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RMDIR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETHOSTNAME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SLEEP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYMLINK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYMLINKAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TRUNCATE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TTYNAME_R]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_NONBLOCKING]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLINK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLINKAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_USLEEP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WRITE]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ACCESS], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CHDIR], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CLOSE], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_DUP], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_DUP2], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECL], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECLE], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECLP], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECV], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVE], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVP], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVPE], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETCWD], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETPID], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ISATTY], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_LSEEK], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_READ], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_RMDIR], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_SWAB], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_UNLINK], [1]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_WRITE], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_UNISTD_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) -]) -m4trace:gnulib-m4/unistd_h.m4:171: -1- AC_DEFUN([gl_UNISTD_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_CHOWN=1; AC_SUBST([HAVE_CHOWN]) - HAVE_COPY_FILE_RANGE=1; AC_SUBST([HAVE_COPY_FILE_RANGE]) - HAVE_DUP3=1; AC_SUBST([HAVE_DUP3]) - HAVE_EUIDACCESS=1; AC_SUBST([HAVE_EUIDACCESS]) - HAVE_EXECVPE=1; AC_SUBST([HAVE_EXECVPE]) - HAVE_FACCESSAT=1; AC_SUBST([HAVE_FACCESSAT]) - HAVE_FCHDIR=1; AC_SUBST([HAVE_FCHDIR]) - HAVE_FCHOWNAT=1; AC_SUBST([HAVE_FCHOWNAT]) - HAVE_FDATASYNC=1; AC_SUBST([HAVE_FDATASYNC]) - HAVE_FSYNC=1; AC_SUBST([HAVE_FSYNC]) - HAVE_FTRUNCATE=1; AC_SUBST([HAVE_FTRUNCATE]) - HAVE_GETDTABLESIZE=1; AC_SUBST([HAVE_GETDTABLESIZE]) - HAVE_GETENTROPY=1; AC_SUBST([HAVE_GETENTROPY]) - HAVE_GETGROUPS=1; AC_SUBST([HAVE_GETGROUPS]) - HAVE_GETHOSTNAME=1; AC_SUBST([HAVE_GETHOSTNAME]) - HAVE_GETLOGIN=1; AC_SUBST([HAVE_GETLOGIN]) - HAVE_GETPAGESIZE=1; AC_SUBST([HAVE_GETPAGESIZE]) - HAVE_GETPASS=1; AC_SUBST([HAVE_GETPASS]) - HAVE_GROUP_MEMBER=1; AC_SUBST([HAVE_GROUP_MEMBER]) - HAVE_LCHOWN=1; AC_SUBST([HAVE_LCHOWN]) - HAVE_LINK=1; AC_SUBST([HAVE_LINK]) - HAVE_LINKAT=1; AC_SUBST([HAVE_LINKAT]) - HAVE_PIPE=1; AC_SUBST([HAVE_PIPE]) - HAVE_PIPE2=1; AC_SUBST([HAVE_PIPE2]) - HAVE_PREAD=1; AC_SUBST([HAVE_PREAD]) - HAVE_PWRITE=1; AC_SUBST([HAVE_PWRITE]) - HAVE_READLINK=1; AC_SUBST([HAVE_READLINK]) - HAVE_READLINKAT=1; AC_SUBST([HAVE_READLINKAT]) - HAVE_SETHOSTNAME=1; AC_SUBST([HAVE_SETHOSTNAME]) - HAVE_SLEEP=1; AC_SUBST([HAVE_SLEEP]) - HAVE_SYMLINK=1; AC_SUBST([HAVE_SYMLINK]) - HAVE_SYMLINKAT=1; AC_SUBST([HAVE_SYMLINKAT]) - HAVE_UNLINKAT=1; AC_SUBST([HAVE_UNLINKAT]) - HAVE_USLEEP=1; AC_SUBST([HAVE_USLEEP]) - HAVE_DECL_ENVIRON=1; AC_SUBST([HAVE_DECL_ENVIRON]) - HAVE_DECL_EXECVPE=1; AC_SUBST([HAVE_DECL_EXECVPE]) - HAVE_DECL_FCHDIR=1; AC_SUBST([HAVE_DECL_FCHDIR]) - HAVE_DECL_FDATASYNC=1; AC_SUBST([HAVE_DECL_FDATASYNC]) - HAVE_DECL_GETDOMAINNAME=1; AC_SUBST([HAVE_DECL_GETDOMAINNAME]) - HAVE_DECL_GETLOGIN=1; AC_SUBST([HAVE_DECL_GETLOGIN]) - HAVE_DECL_GETLOGIN_R=1; AC_SUBST([HAVE_DECL_GETLOGIN_R]) - HAVE_DECL_GETPAGESIZE=1; AC_SUBST([HAVE_DECL_GETPAGESIZE]) - HAVE_DECL_GETUSERSHELL=1; AC_SUBST([HAVE_DECL_GETUSERSHELL]) - HAVE_DECL_SETHOSTNAME=1; AC_SUBST([HAVE_DECL_SETHOSTNAME]) - HAVE_DECL_TRUNCATE=1; AC_SUBST([HAVE_DECL_TRUNCATE]) - HAVE_DECL_TTYNAME_R=1; AC_SUBST([HAVE_DECL_TTYNAME_R]) - HAVE_OS_H=0; AC_SUBST([HAVE_OS_H]) - HAVE_SYS_PARAM_H=0; AC_SUBST([HAVE_SYS_PARAM_H]) - REPLACE_ACCESS=0; AC_SUBST([REPLACE_ACCESS]) - REPLACE_CHOWN=0; AC_SUBST([REPLACE_CHOWN]) - REPLACE_CLOSE=0; AC_SUBST([REPLACE_CLOSE]) - REPLACE_COPY_FILE_RANGE=0; AC_SUBST([REPLACE_COPY_FILE_RANGE]) - REPLACE_DUP=0; AC_SUBST([REPLACE_DUP]) - REPLACE_DUP2=0; AC_SUBST([REPLACE_DUP2]) - REPLACE_DUP3=0; AC_SUBST([REPLACE_DUP3]) - REPLACE_EXECL=0; AC_SUBST([REPLACE_EXECL]) - REPLACE_EXECLE=0; AC_SUBST([REPLACE_EXECLE]) - REPLACE_EXECLP=0; AC_SUBST([REPLACE_EXECLP]) - REPLACE_EXECV=0; AC_SUBST([REPLACE_EXECV]) - REPLACE_EXECVE=0; AC_SUBST([REPLACE_EXECVE]) - REPLACE_EXECVP=0; AC_SUBST([REPLACE_EXECVP]) - REPLACE_EXECVPE=0; AC_SUBST([REPLACE_EXECVPE]) - REPLACE_FACCESSAT=0; AC_SUBST([REPLACE_FACCESSAT]) - REPLACE_FCHDIR=0; AC_SUBST([REPLACE_FCHDIR]) - REPLACE_FCHOWNAT=0; AC_SUBST([REPLACE_FCHOWNAT]) - REPLACE_FDATASYNC=0; AC_SUBST([REPLACE_FDATASYNC]) - REPLACE_FTRUNCATE=0; AC_SUBST([REPLACE_FTRUNCATE]) - REPLACE_GETCWD=0; AC_SUBST([REPLACE_GETCWD]) - REPLACE_GETDOMAINNAME=0; AC_SUBST([REPLACE_GETDOMAINNAME]) - REPLACE_GETDTABLESIZE=0; AC_SUBST([REPLACE_GETDTABLESIZE]) - REPLACE_GETENTROPY=0; AC_SUBST([REPLACE_GETENTROPY]) - REPLACE_GETLOGIN_R=0; AC_SUBST([REPLACE_GETLOGIN_R]) - REPLACE_GETGROUPS=0; AC_SUBST([REPLACE_GETGROUPS]) - REPLACE_GETPAGESIZE=0; AC_SUBST([REPLACE_GETPAGESIZE]) - REPLACE_GETPASS=0; AC_SUBST([REPLACE_GETPASS]) - REPLACE_GETPASS_FOR_GETPASS_GNU=0; AC_SUBST([REPLACE_GETPASS_FOR_GETPASS_GNU]) - REPLACE_ISATTY=0; AC_SUBST([REPLACE_ISATTY]) - REPLACE_LCHOWN=0; AC_SUBST([REPLACE_LCHOWN]) - REPLACE_LINK=0; AC_SUBST([REPLACE_LINK]) - REPLACE_LINKAT=0; AC_SUBST([REPLACE_LINKAT]) - REPLACE_LSEEK=0; AC_SUBST([REPLACE_LSEEK]) - REPLACE_PIPE2=0; AC_SUBST([REPLACE_PIPE2]) - REPLACE_PREAD=0; AC_SUBST([REPLACE_PREAD]) - REPLACE_PWRITE=0; AC_SUBST([REPLACE_PWRITE]) - REPLACE_READ=0; AC_SUBST([REPLACE_READ]) - REPLACE_READLINK=0; AC_SUBST([REPLACE_READLINK]) - REPLACE_READLINKAT=0; AC_SUBST([REPLACE_READLINKAT]) - REPLACE_RMDIR=0; AC_SUBST([REPLACE_RMDIR]) - REPLACE_SETHOSTNAME=0; AC_SUBST([REPLACE_SETHOSTNAME]) - REPLACE_SLEEP=0; AC_SUBST([REPLACE_SLEEP]) - REPLACE_SYMLINK=0; AC_SUBST([REPLACE_SYMLINK]) - REPLACE_SYMLINKAT=0; AC_SUBST([REPLACE_SYMLINKAT]) - REPLACE_TRUNCATE=0; AC_SUBST([REPLACE_TRUNCATE]) - REPLACE_TTYNAME_R=0; AC_SUBST([REPLACE_TTYNAME_R]) - REPLACE_UNLINK=0; AC_SUBST([REPLACE_UNLINK]) - REPLACE_UNLINKAT=0; AC_SUBST([REPLACE_UNLINKAT]) - REPLACE_USLEEP=0; AC_SUBST([REPLACE_USLEEP]) - REPLACE_WRITE=0; AC_SUBST([REPLACE_WRITE]) - UNISTD_H_HAVE_SYS_RANDOM_H=0; AC_SUBST([UNISTD_H_HAVE_SYS_RANDOM_H]) - UNISTD_H_HAVE_WINSOCK2_H=0; AC_SUBST([UNISTD_H_HAVE_WINSOCK2_H]) - UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS=0; - AC_SUBST([UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS]) -]) -m4trace:gnulib-m4/unlocked-io.m4:17: -1- AC_DEFUN([gl_FUNC_GLIBC_UNLOCKED_IO], [ - dnl Persuade glibc and Solaris to declare - dnl fgets_unlocked(), fputs_unlocked() etc. - AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) - - AC_CHECK_DECLS_ONCE([clearerr_unlocked]) - AC_CHECK_DECLS_ONCE([feof_unlocked]) - AC_CHECK_DECLS_ONCE([ferror_unlocked]) - AC_CHECK_DECLS_ONCE([fflush_unlocked]) - AC_CHECK_DECLS_ONCE([fgets_unlocked]) - AC_CHECK_DECLS_ONCE([fputc_unlocked]) - AC_CHECK_DECLS_ONCE([fputs_unlocked]) - AC_CHECK_DECLS_ONCE([fread_unlocked]) - AC_CHECK_DECLS_ONCE([fwrite_unlocked]) - AC_CHECK_DECLS_ONCE([getc_unlocked]) - AC_CHECK_DECLS_ONCE([getchar_unlocked]) - AC_CHECK_DECLS_ONCE([putc_unlocked]) - AC_CHECK_DECLS_ONCE([putchar_unlocked]) -]) -m4trace:gnulib-m4/warn-on-use.m4:26: -1- AC_DEFUN([gl_WARN_ON_USE_PREPARE], [ - m4_ifdef([gl_POSIXCHECK], - [m4_foreach_w([gl_decl], [$2], - [AH_TEMPLATE([HAVE_RAW_DECL_]AS_TR_CPP(m4_defn([gl_decl])), - [Define to 1 if ]m4_defn([gl_decl])[ is declared even after - undefining macros.])])dnl - for gl_func in m4_flatten([$2]); do - AS_VAR_PUSHDEF([gl_Symbol], [gl_cv_have_raw_decl_$gl_func])dnl - dnl As a workaround to implicit built-in function declarations in - dnl clang (e.g. strndup), reference ac_compile_for_check_decl instead - dnl of ac_compile. If, for whatever reason, the override of AC_PROG_CC - dnl in zzgnulib.m4 is inactive, use the original ac_compile. - ac_saved_ac_compile="$ac_compile" - if test -n "$ac_compile_for_check_decl"; then - ac_compile="$ac_compile_for_check_decl" - fi - AC_CACHE_CHECK([whether $gl_func is declared without a macro], - [gl_Symbol], - [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$1], -[[#undef $gl_func - (void) $gl_func;]])], - [AS_VAR_SET([gl_Symbol], [yes])], [AS_VAR_SET([gl_Symbol], [no])])]) - ac_compile="$ac_saved_ac_compile" - AS_VAR_IF([gl_Symbol], [yes], - [AC_DEFINE_UNQUOTED(AS_TR_CPP([HAVE_RAW_DECL_$gl_func]), [1]) - dnl Shortcut for an AC_CHECK_DECL invocation that may come later: - dnl If the raw declaration exists with the given includes, then - dnl AC_CHECK_DECL with its many includes would see it as well. - dnl So, set a cache variable to allow skipping any later - dnl AC_CHECK_DECL invocation for $gl_func. - eval "ac_cv_have_decl_$gl_func=yes" - ]) - AS_VAR_POPDEF([gl_Symbol])dnl - done - ]) -]) -m4trace:gnulib-m4/warnings.m4:17: -1- AC_DEFUN([gl_COMPILER_OPTION_IF], [ -AS_VAR_PUSHDEF([gl_Warn], [gl_cv_warn_[]_AC_LANG_ABBREV[]_$1])dnl -AS_VAR_PUSHDEF([gl_Flags], [_AC_LANG_PREFIX[]FLAGS])dnl -AS_LITERAL_IF([$1], - [m4_pushdef([gl_Positive], m4_bpatsubst([$1], [^-Wno-], [-W]))], - [gl_positive="$1" -case $gl_positive in - -Wno-*) gl_positive=-W`expr "X$gl_positive" : 'X-Wno-\(.*\)'` ;; -esac -m4_pushdef([gl_Positive], [$gl_positive])])dnl -AC_CACHE_CHECK([whether _AC_LANG compiler handles $1], [gl_Warn], [ - gl_saved_compiler_FLAGS="$gl_Flags" - AS_VAR_APPEND(m4_defn([gl_Flags]), - [" $gl_unknown_warnings_are_errors ]m4_defn([gl_Positive])["]) - AC_LINK_IFELSE([m4_default([$4], [AC_LANG_PROGRAM([[]])])], - [AS_VAR_SET([gl_Warn], [yes])], - [AS_VAR_SET([gl_Warn], [no])]) - gl_Flags="$gl_saved_compiler_FLAGS" -]) -AS_VAR_IF(gl_Warn, [yes], [$2], [$3]) -m4_popdef([gl_Positive])dnl -AS_VAR_POPDEF([gl_Flags])dnl -AS_VAR_POPDEF([gl_Warn])dnl -]) -m4trace:gnulib-m4/warnings.m4:49: -1- AC_DEFUN([gl_UNKNOWN_WARNINGS_ARE_ERRORS], [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) -m4trace:gnulib-m4/warnings.m4:53: -1- AC_DEFUN([gl_UNKNOWN_WARNINGS_ARE_ERRORS(C)], [ - AC_LANG_PUSH([C]) - gl_UNKNOWN_WARNINGS_ARE_ERRORS_IMPL - AC_LANG_POP([C]) -]) -m4trace:gnulib-m4/warnings.m4:61: -1- AC_DEFUN([gl_UNKNOWN_WARNINGS_ARE_ERRORS(C++)], [ - AC_LANG_PUSH([C++]) - gl_UNKNOWN_WARNINGS_ARE_ERRORS_IMPL - AC_LANG_POP([C++]) -]) -m4trace:gnulib-m4/warnings.m4:69: -1- AC_DEFUN([gl_UNKNOWN_WARNINGS_ARE_ERRORS(Objective C)], [ - AC_LANG_PUSH([Objective C]) - gl_UNKNOWN_WARNINGS_ARE_ERRORS_IMPL - AC_LANG_POP([Objective C]) -]) -m4trace:gnulib-m4/warnings.m4:76: -1- AC_DEFUN([gl_UNKNOWN_WARNINGS_ARE_ERRORS_IMPL], [gl_COMPILER_OPTION_IF([-Werror -Wunknown-warning-option], - [gl_unknown_warnings_are_errors='-Wunknown-warning-option -Werror'], - [gl_unknown_warnings_are_errors=])]) -m4trace:gnulib-m4/warnings.m4:92: -1- AC_DEFUN([gl_WARN_ADD], [AC_REQUIRE([gl_UNKNOWN_WARNINGS_ARE_ERRORS(]_AC_LANG[)]) -gl_COMPILER_OPTION_IF([$1], - [AS_VAR_APPEND(m4_if([$2], [], [[WARN_]_AC_LANG_PREFIX[FLAGS]], [[$2]]), [" $1"])], - [], - [$3]) -m4_ifval([$2], - [AS_LITERAL_IF([$2], [AC_SUBST([$2])])], - [AC_SUBST([WARN_]_AC_LANG_PREFIX[FLAGS])])dnl -]) -m4trace:gnulib-m4/warnings.m4:110: -1- AC_DEFUN([gl_CC_INHIBIT_WARNINGS], [ - AC_REQUIRE([AC_PROG_CC]) - AC_CACHE_CHECK([for C compiler option to inhibit all warnings], - [gl_cv_cc_winhibit], - [rm -f conftest* - echo 'int dummy;' > conftest.c - AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -c conftest.c 2>conftest1.err]) >/dev/null - AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -w -c conftest.c 2>conftest2.err]) >/dev/null - if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then - gl_cv_cc_winhibit='-w' - else - gl_cv_cc_winhibit=none - fi - rm -f conftest* - ]) - case "$gl_cv_cc_winhibit" in - none) GL_CFLAG_INHIBIT_WARNINGS='' ;; - *) - GL_CFLAG_INHIBIT_WARNINGS="$gl_cv_cc_winhibit" - dnl If all warnings are inhibited, there's no point in having the GCC - dnl analyzer enabled. This saves RAM requirements and CPU consumption. - gl_WARN_ADD([-fno-analyzer], [GL_CFLAG_INHIBIT_WARNINGS]) - ;; - esac - AC_SUBST([GL_CFLAG_INHIBIT_WARNINGS]) -]) -m4trace:gnulib-m4/warnings.m4:141: -1- AC_DEFUN([gl_CXX_INHIBIT_WARNINGS], [ - dnl Requires AC_PROG_CXX or gl_PROG_ANSI_CXX. - if test -n "$CXX" && test "$CXX" != no; then - AC_CACHE_CHECK([for C++ compiler option to inhibit all warnings], - [gl_cv_cxx_winhibit], - [rm -f conftest* - echo 'int dummy;' > conftest.cc - AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -c conftest.cc 2>conftest1.err]) >/dev/null - AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -w -c conftest.cc 2>conftest2.err]) >/dev/null - if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then - gl_cv_cxx_winhibit='-w' - else - gl_cv_cxx_winhibit=none - fi - rm -f conftest* - ]) - case "$gl_cv_cxx_winhibit" in - none) GL_CXXFLAG_INHIBIT_WARNINGS='' ;; - *) - GL_CXXFLAG_INHIBIT_WARNINGS="$gl_cv_cxx_winhibit" - dnl If all warnings are inhibited, there's no point in having the GCC - dnl analyzer enabled. This saves RAM requirements and CPU consumption. - gl_WARN_ADD([-fno-analyzer], [GL_CXXFLAG_INHIBIT_WARNINGS]) - ;; - esac - else - GL_CXXFLAG_INHIBIT_WARNINGS='' - fi - AC_SUBST([GL_CXXFLAG_INHIBIT_WARNINGS]) -]) -m4trace:gnulib-m4/wchar_h.m4:12: -1- AC_DEFUN_ONCE([gl_WCHAR_H], [ - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) - AC_REQUIRE([gl_WCHAR_H_INLINE_OK]) - dnl Prepare for creating substitute . - dnl Check for (missing in Linux uClibc when built without wide - dnl character support). - dnl is always overridden, because of GNULIB_POSIXCHECK. - gl_CHECK_NEXT_HEADERS([wchar.h]) - if test $ac_cv_header_wchar_h = yes; then - HAVE_WCHAR_H=1 - else - HAVE_WCHAR_H=0 - fi - AC_SUBST([HAVE_WCHAR_H]) - - AC_REQUIRE([gl_FEATURES_H]) - - AC_REQUIRE([gt_TYPE_WINT_T]) - if test $gt_cv_c_wint_t = yes; then - HAVE_WINT_T=1 - else - HAVE_WINT_T=0 - fi - AC_SUBST([HAVE_WINT_T]) - - AC_REQUIRE([gl_TYPE_WINT_T_PREREQ]) - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[ - #include - ]], - [btowc wctob mbsinit mbrtowc mbrlen mbsrtowcs mbsnrtowcs wcrtomb - wcsrtombs wcsnrtombs wcwidth - wmemchr wmemcmp wmemcpy wmemmove wmempcpy wmemset - wcslen wcsnlen wcscpy wcpcpy wcsncpy wcpncpy wcscat wcsncat wcscmp - wcsncmp wcscasecmp wcsncasecmp wcscoll wcsxfrm wcsdup wcschr wcsrchr - wcscspn wcsspn wcspbrk wcsstr wcstok wcswidth wcsftime - ]) - - AC_REQUIRE([AC_C_RESTRICT]) - - AC_CHECK_DECLS([wcsdup], [], [], [[ - #include - ]]) - if test $ac_cv_have_decl_wcsdup = no; then - HAVE_DECL_WCSDUP=0 - fi -]) -m4trace:gnulib-m4/wchar_h.m4:64: -1- AC_DEFUN([gl_WCHAR_H_INLINE_OK], [ - dnl Test whether suffers due to the transition from '__inline' to - dnl 'gnu_inline'. See - dnl and . In summary, - dnl glibc version 2.5 or older, together with gcc version 4.3 or newer and - dnl the option -std=c99 or -std=gnu99, leads to a broken . - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CACHE_CHECK([whether uses 'inline' correctly], - [gl_cv_header_wchar_h_correct_inline], - [gl_cv_header_wchar_h_correct_inline=yes - case "$host_os" in - *-gnu* | gnu*) - AC_LANG_CONFTEST([ - AC_LANG_SOURCE([[ - #define wcstod renamed_wcstod - #include - extern int zero (void); - int main () { return zero(); } - ]])]) - dnl Do not rename the object file from conftest.$ac_objext to - dnl conftest1.$ac_objext, as this will cause the link to fail on - dnl z/OS when using the XPLINK object format (due to duplicate - dnl CSECT names). Instead, temporarily redefine $ac_compile so - dnl that the object file has the latter name from the start. - saved_ac_compile="$ac_compile" - ac_compile=`echo "$saved_ac_compile" | sed s/conftest/conftest1/` - if echo '#include "conftest.c"' >conftest1.c \ - && AC_TRY_EVAL([ac_compile]); then - AC_LANG_CONFTEST([ - AC_LANG_SOURCE([[ - #define wcstod renamed_wcstod - #include - int zero (void) { return 0; } - ]])]) - dnl See note above about renaming object files. - ac_compile=`echo "$saved_ac_compile" | sed s/conftest/conftest2/` - if echo '#include "conftest.c"' >conftest2.c \ - && AC_TRY_EVAL([ac_compile]); then - if $CC -o conftest$ac_exeext $CFLAGS $LDFLAGS conftest1.$ac_objext conftest2.$ac_objext $LIBS >&AS_MESSAGE_LOG_FD 2>&1; then - : - else - gl_cv_header_wchar_h_correct_inline=no - fi - fi - fi - ac_compile="$saved_ac_compile" - rm -f conftest[12].c conftest[12].$ac_objext conftest$ac_exeext - ;; - esac - ]) - if test $gl_cv_header_wchar_h_correct_inline = no; then - AC_MSG_ERROR([ cannot be used with this compiler ($CC $CFLAGS $CPPFLAGS). -This is a known interoperability problem of glibc <= 2.5 with gcc >= 4.3 in -C99 mode. You have four options: - - Add the flag -fgnu89-inline to CC and reconfigure, or - - Fix your include files, using parts of - , or - - Use a gcc version older than 4.3, or - - Don't use the flags -std=c99 or -std=gnu99. -Configuration aborted.]) - fi -]) -m4trace:gnulib-m4/wchar_h.m4:132: -1- AC_DEFUN([gl_WCHAR_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_WCHAR_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/wchar_h.m4:144: -1- AC_DEFUN([gl_WCHAR_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_WCHAR_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_BTOWC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTOB]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSINIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSZERO]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOWC]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRTOWCS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNRTOWCS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCRTOMB]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSRTOMBS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNRTOMBS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCWIDTH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMMOVE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMPCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMSET]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNLEN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCPCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCPNCPY]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCAT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCASECMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCASECMP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCOLL]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSXFRM]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSDUP]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSRCHR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCSPN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSSPN]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSPBRK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSSTR]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSTOK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSWIDTH]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSFTIME]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WGETCWD]) - dnl Support Microsoft deprecated alias function names by default. - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_WCSDUP], [1]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_WCHAR_H_MODULE_INDICATOR_DEFAULTS]) - dnl Make sure the shell variable for GNULIB_FREE_POSIX is initialized. - gl_STDLIB_H_REQUIRE_DEFAULTS - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) -]) -m4trace:gnulib-m4/wchar_h.m4:199: -1- AC_DEFUN([gl_WCHAR_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_BTOWC=1; AC_SUBST([HAVE_BTOWC]) - HAVE_MBSINIT=1; AC_SUBST([HAVE_MBSINIT]) - HAVE_MBRTOWC=1; AC_SUBST([HAVE_MBRTOWC]) - HAVE_MBRLEN=1; AC_SUBST([HAVE_MBRLEN]) - HAVE_MBSRTOWCS=1; AC_SUBST([HAVE_MBSRTOWCS]) - HAVE_MBSNRTOWCS=1; AC_SUBST([HAVE_MBSNRTOWCS]) - HAVE_WCRTOMB=1; AC_SUBST([HAVE_WCRTOMB]) - HAVE_WCSRTOMBS=1; AC_SUBST([HAVE_WCSRTOMBS]) - HAVE_WCSNRTOMBS=1; AC_SUBST([HAVE_WCSNRTOMBS]) - HAVE_WMEMCHR=1; AC_SUBST([HAVE_WMEMCHR]) - HAVE_WMEMCMP=1; AC_SUBST([HAVE_WMEMCMP]) - HAVE_WMEMCPY=1; AC_SUBST([HAVE_WMEMCPY]) - HAVE_WMEMMOVE=1; AC_SUBST([HAVE_WMEMMOVE]) - HAVE_WMEMPCPY=1; AC_SUBST([HAVE_WMEMPCPY]) - HAVE_WMEMSET=1; AC_SUBST([HAVE_WMEMSET]) - HAVE_WCSLEN=1; AC_SUBST([HAVE_WCSLEN]) - HAVE_WCSNLEN=1; AC_SUBST([HAVE_WCSNLEN]) - HAVE_WCSCPY=1; AC_SUBST([HAVE_WCSCPY]) - HAVE_WCPCPY=1; AC_SUBST([HAVE_WCPCPY]) - HAVE_WCSNCPY=1; AC_SUBST([HAVE_WCSNCPY]) - HAVE_WCPNCPY=1; AC_SUBST([HAVE_WCPNCPY]) - HAVE_WCSCAT=1; AC_SUBST([HAVE_WCSCAT]) - HAVE_WCSNCAT=1; AC_SUBST([HAVE_WCSNCAT]) - HAVE_WCSCMP=1; AC_SUBST([HAVE_WCSCMP]) - HAVE_WCSNCMP=1; AC_SUBST([HAVE_WCSNCMP]) - HAVE_WCSCASECMP=1; AC_SUBST([HAVE_WCSCASECMP]) - HAVE_WCSNCASECMP=1; AC_SUBST([HAVE_WCSNCASECMP]) - HAVE_WCSCOLL=1; AC_SUBST([HAVE_WCSCOLL]) - HAVE_WCSXFRM=1; AC_SUBST([HAVE_WCSXFRM]) - HAVE_WCSDUP=1; AC_SUBST([HAVE_WCSDUP]) - HAVE_WCSCHR=1; AC_SUBST([HAVE_WCSCHR]) - HAVE_WCSRCHR=1; AC_SUBST([HAVE_WCSRCHR]) - HAVE_WCSCSPN=1; AC_SUBST([HAVE_WCSCSPN]) - HAVE_WCSSPN=1; AC_SUBST([HAVE_WCSSPN]) - HAVE_WCSPBRK=1; AC_SUBST([HAVE_WCSPBRK]) - HAVE_WCSSTR=1; AC_SUBST([HAVE_WCSSTR]) - HAVE_WCSTOK=1; AC_SUBST([HAVE_WCSTOK]) - HAVE_WCSWIDTH=1; AC_SUBST([HAVE_WCSWIDTH]) - HAVE_WCSFTIME=1; AC_SUBST([HAVE_WCSFTIME]) - HAVE_DECL_WCTOB=1; AC_SUBST([HAVE_DECL_WCTOB]) - HAVE_DECL_WCSDUP=1; AC_SUBST([HAVE_DECL_WCSDUP]) - HAVE_DECL_WCWIDTH=1; AC_SUBST([HAVE_DECL_WCWIDTH]) - REPLACE_MBSTATE_T=0; AC_SUBST([REPLACE_MBSTATE_T]) - REPLACE_BTOWC=0; AC_SUBST([REPLACE_BTOWC]) - REPLACE_WCTOB=0; AC_SUBST([REPLACE_WCTOB]) - REPLACE_MBSINIT=0; AC_SUBST([REPLACE_MBSINIT]) - REPLACE_MBRTOWC=0; AC_SUBST([REPLACE_MBRTOWC]) - REPLACE_MBRLEN=0; AC_SUBST([REPLACE_MBRLEN]) - REPLACE_MBSRTOWCS=0; AC_SUBST([REPLACE_MBSRTOWCS]) - REPLACE_MBSNRTOWCS=0; AC_SUBST([REPLACE_MBSNRTOWCS]) - REPLACE_WCRTOMB=0; AC_SUBST([REPLACE_WCRTOMB]) - REPLACE_WCSRTOMBS=0; AC_SUBST([REPLACE_WCSRTOMBS]) - REPLACE_WCSNRTOMBS=0; AC_SUBST([REPLACE_WCSNRTOMBS]) - REPLACE_WCWIDTH=0; AC_SUBST([REPLACE_WCWIDTH]) - REPLACE_WCSWIDTH=0; AC_SUBST([REPLACE_WCSWIDTH]) - REPLACE_WCSFTIME=0; AC_SUBST([REPLACE_WCSFTIME]) - REPLACE_WCSCMP=0; AC_SUBST([REPLACE_WCSCMP]) - REPLACE_WCSNCMP=0; AC_SUBST([REPLACE_WCSNCMP]) - REPLACE_WCSSTR=0; AC_SUBST([REPLACE_WCSSTR]) - REPLACE_WCSTOK=0; AC_SUBST([REPLACE_WCSTOK]) - REPLACE_WMEMCMP=0; AC_SUBST([REPLACE_WMEMCMP]) - REPLACE_WMEMPCPY=0; AC_SUBST([REPLACE_WMEMPCPY]) -]) -m4trace:gnulib-m4/wchar_t.m4:11: -1- AC_DEFUN([gt_TYPE_WCHAR_T], [ - AC_CACHE_CHECK([for wchar_t], [gt_cv_c_wchar_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - wchar_t foo = (wchar_t)'\0';]], - [[]])], - [gt_cv_c_wchar_t=yes], - [gt_cv_c_wchar_t=no])]) - if test $gt_cv_c_wchar_t = yes; then - AC_DEFINE([HAVE_WCHAR_T], [1], [Define if you have the 'wchar_t' type.]) - fi -]) -m4trace:gnulib-m4/wctype_h.m4:12: -1- AC_DEFUN_ONCE([gl_WCTYPE_H], [ - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) - AC_REQUIRE([AC_PROG_CC]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_CHECK_FUNCS_ONCE([iswcntrl]) - if test $ac_cv_func_iswcntrl = yes; then - HAVE_ISWCNTRL=1 - else - HAVE_ISWCNTRL=0 - fi - AC_SUBST([HAVE_ISWCNTRL]) - - AC_REQUIRE([gt_TYPE_WINT_T]) - if test $gt_cv_c_wint_t = yes; then - HAVE_WINT_T=1 - else - HAVE_WINT_T=0 - fi - AC_SUBST([HAVE_WINT_T]) - - AC_REQUIRE([gl_TYPE_WINT_T_PREREQ]) - - gl_CHECK_NEXT_HEADERS([wctype.h]) - if test $ac_cv_header_wctype_h = yes; then - if test $ac_cv_func_iswcntrl = yes; then - dnl Linux libc5 has an iswprint function that returns 0 for all arguments. - dnl The other functions are likely broken in the same way. - AC_CACHE_CHECK([whether iswcntrl works], [gl_cv_func_iswcntrl_works], - [ - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ - #include - #include - int main () { return iswprint ('x') == 0; } - ]])], - [gl_cv_func_iswcntrl_works=yes], [gl_cv_func_iswcntrl_works=no], - [dnl Guess no on Linux libc5, yes otherwise. - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include - #if __GNU_LIBRARY__ == 1 - Linux libc5 i18n is broken. - #endif]], [[]])], - [gl_cv_func_iswcntrl_works="guessing yes"], - [gl_cv_func_iswcntrl_works="guessing no"]) - ]) - ]) - fi - HAVE_WCTYPE_H=1 - else - HAVE_WCTYPE_H=0 - fi - AC_SUBST([HAVE_WCTYPE_H]) - - if test $GNULIBHEADERS_OVERRIDE_WINT_T = 1; then - REPLACE_ISWCNTRL=1 - else - case "$gl_cv_func_iswcntrl_works" in - *yes) REPLACE_ISWCNTRL=0 ;; - *) REPLACE_ISWCNTRL=1 ;; - esac - fi - AC_SUBST([REPLACE_ISWCNTRL]) - - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; then - dnl Redefine all of iswcntrl, ..., iswxdigit in . - : - fi - - if test $REPLACE_ISWCNTRL = 1; then - REPLACE_TOWLOWER=1 - else - AC_CHECK_FUNCS([towlower]) - if test $ac_cv_func_towlower = yes; then - REPLACE_TOWLOWER=0 - else - AC_CHECK_DECLS([towlower],,, - [[#include - #if HAVE_WCTYPE_H - # include - #endif - ]]) - if test $ac_cv_have_decl_towlower = yes; then - dnl On Minix 3.1.8, the system's declares towlower() and - dnl towupper() although it does not have the functions. Avoid a - dnl collision with gnulib's replacement. - REPLACE_TOWLOWER=1 - else - REPLACE_TOWLOWER=0 - fi - fi - fi - AC_SUBST([REPLACE_TOWLOWER]) - - if test $HAVE_ISWCNTRL = 0 || test $REPLACE_TOWLOWER = 1; then - dnl Redefine towlower, towupper in . - : - fi - - dnl We assume that the wctype() and iswctype() functions exist if and only - dnl if the type wctype_t is defined in or in if that - dnl exists. - dnl HP-UX 11.00 declares all these in and lacks . - AC_CACHE_CHECK([for wctype_t], [gl_cv_type_wctype_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #if HAVE_WCTYPE_H - # include - #endif - wctype_t a; - ]], - [[]])], - [gl_cv_type_wctype_t=yes], - [gl_cv_type_wctype_t=no]) - ]) - if test $gl_cv_type_wctype_t = no; then - HAVE_WCTYPE_T=0 - fi - - dnl We assume that the wctrans() and towctrans() functions exist if and only - dnl if the type wctrans_t is defined in . - AC_CACHE_CHECK([for wctrans_t], [gl_cv_type_wctrans_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - wctrans_t a; - ]], - [[]])], - [gl_cv_type_wctrans_t=yes], - [gl_cv_type_wctrans_t=no]) - ]) - if test $gl_cv_type_wctrans_t = no; then - HAVE_WCTRANS_T=0 - fi - - dnl Check for declarations of anything we want to poison if the - dnl corresponding gnulib module is not in use. - gl_WARN_ON_USE_PREPARE([[ -#if !(defined __GLIBC__ && !defined __UCLIBC__) -# include -#endif -#include - ]], - [wctype iswctype wctrans towctrans - ]) -]) -m4trace:gnulib-m4/wctype_h.m4:164: -1- AC_DEFUN([gl_WCTYPE_MODULE_INDICATOR], [ - dnl Ensure to expand the default settings once only. - gl_WCTYPE_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_SET_VARIABLE([$1]) - dnl Define it also as a C macro, for the benefit of the unit tests. - gl_MODULE_INDICATOR_FOR_TESTS([$1]) -]) -m4trace:gnulib-m4/wctype_h.m4:176: -1- AC_DEFUN([gl_WCTYPE_H_REQUIRE_DEFAULTS], [ - m4_defun(GL_MODULE_INDICATOR_PREFIX[_WCTYPE_H_MODULE_INDICATOR_DEFAULTS], [ - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWBLANK]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWDIGIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWPUNCT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWXDIGIT]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTYPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWCTYPE]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTRANS]) - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TOWCTRANS]) - ]) - m4_require(GL_MODULE_INDICATOR_PREFIX[_WCTYPE_H_MODULE_INDICATOR_DEFAULTS]) - AC_REQUIRE([gl_WCTYPE_H_DEFAULTS]) -]) -m4trace:gnulib-m4/wctype_h.m4:192: -1- AC_DEFUN([gl_WCTYPE_H_DEFAULTS], [ - dnl Assume proper GNU behavior unless another module says otherwise. - HAVE_ISWBLANK=1; AC_SUBST([HAVE_ISWBLANK]) - HAVE_WCTYPE_T=1; AC_SUBST([HAVE_WCTYPE_T]) - HAVE_WCTRANS_T=1; AC_SUBST([HAVE_WCTRANS_T]) - REPLACE_ISWBLANK=0; AC_SUBST([REPLACE_ISWBLANK]) - REPLACE_ISWDIGIT=0; AC_SUBST([REPLACE_ISWDIGIT]) - REPLACE_ISWPUNCT=0; AC_SUBST([REPLACE_ISWPUNCT]) - REPLACE_ISWXDIGIT=0; AC_SUBST([REPLACE_ISWXDIGIT]) - REPLACE_WCTRANS=0; AC_SUBST([REPLACE_WCTRANS]) - REPLACE_WCTYPE=0; AC_SUBST([REPLACE_WCTYPE]) -]) -m4trace:gnulib-m4/wcwidth.m4:7: -1- AC_DEFUN([gl_FUNC_WCWIDTH], [ - AC_REQUIRE([gl_WCHAR_H_DEFAULTS]) - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - dnl Persuade glibc to declare wcwidth(). - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - AC_REQUIRE([gt_TYPE_WCHAR_T]) - AC_REQUIRE([gt_TYPE_WINT_T]) - - AC_CHECK_HEADERS_ONCE([wchar.h]) - AC_CHECK_FUNCS_ONCE([wcwidth]) - - AC_CHECK_DECLS([wcwidth], [], [], [[ - #include - ]]) - if test $ac_cv_have_decl_wcwidth != yes; then - HAVE_DECL_WCWIDTH=0 - fi - - if test $ac_cv_func_wcwidth != yes; then - AC_CACHE_CHECK([whether wcwidth is a macro], - [gl_cv_func_wcwidth_macro], - [AC_EGREP_CPP([wchar_header_defines_wcwidth], [ -#include -#ifdef wcwidth - wchar_header_defines_wcwidth -#endif], - [gl_cv_func_wcwidth_macro=yes], - [gl_cv_func_wcwidth_macro=no]) - ]) - fi - - if test $ac_cv_func_wcwidth = yes || test $gl_cv_func_wcwidth_macro = yes; then - HAVE_WCWIDTH=1 - dnl On Mac OS X 10.3, wcwidth(0x0301) (COMBINING ACUTE ACCENT) returns 1. - dnl On macOS 12.5, NetBSD 9.0, OpenBSD 5.0, MidnightBSD 1.1, - dnl wcwidth(0x05B0) (HEBREW POINT SHEVA) returns 1. - dnl On macOS 12.5, NetBSD 9.0, MidnightBSD 1.1, OSF/1 5.1, - dnl wcwidth(0x200B) (ZERO WIDTH SPACE) returns 1. - dnl On OpenBSD 5.8, wcwidth(0xFF1A) (FULLWIDTH COLON) returns 0. - dnl This leads to bugs in 'ls' (coreutils). - dnl On Solaris 11.4, wcwidth(0x2202) (PARTIAL DIFFERENTIAL) returns 2, - dnl even in Western locales. - AC_CACHE_CHECK([whether wcwidth works reasonably in UTF-8 locales], - [gl_cv_func_wcwidth_works], - [ - AC_RUN_IFELSE( - [AC_LANG_SOURCE([[ -#include -#include -#if !HAVE_DECL_WCWIDTH -extern -# ifdef __cplusplus -"C" -# endif -int wcwidth (int); -#endif -int main () -{ - int result = 0; - if (setlocale (LC_ALL, "en_US.UTF-8") != NULL) - { - if (wcwidth (0x0301) > 0) - result |= 1; - if (wcwidth (0x05B0) > 0) - result |= 2; - if (wcwidth (0x200B) > 0) - result |= 4; - if (wcwidth (0xFF1A) == 0) - result |= 8; - if (wcwidth (0x2202) > 1) - result |= 16; - } - return result; -}]])], - [gl_cv_func_wcwidth_works=yes], - [gl_cv_func_wcwidth_works=no], - [ -changequote(,)dnl - case "$host_os" in - # Guess yes on glibc systems. - *-gnu* | gnu*) gl_cv_func_wcwidth_works="guessing yes";; - # Guess yes on musl systems. - *-musl* | midipix*) gl_cv_func_wcwidth_works="guessing yes";; - # Guess yes on AIX 7 systems. - aix[7-9]*) gl_cv_func_wcwidth_works="guessing yes";; - *) gl_cv_func_wcwidth_works="$gl_cross_guess_normal";; - esac -changequote([,])dnl - ]) - ]) - case "$gl_cv_func_wcwidth_works" in - *yes) ;; - *no) REPLACE_WCWIDTH=1 ;; - esac - else - HAVE_WCWIDTH=0 - fi - dnl We don't substitute HAVE_WCWIDTH. We assume that if the system does not - dnl have the wcwidth function, then it does not declare it. -]) -m4trace:gnulib-m4/wcwidth.m4:112: -1- AC_DEFUN([gl_PREREQ_WCWIDTH], [ - AC_REQUIRE([AC_C_INLINE]) - : -]) -m4trace:gnulib-m4/wint_t.m4:12: -1- AC_DEFUN([gt_TYPE_WINT_T], [ - AC_CACHE_CHECK([for wint_t], [gt_cv_c_wint_t], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - wint_t foo = (wchar_t)'\0';]], - [[]])], - [gt_cv_c_wint_t=yes], - [gt_cv_c_wint_t=no])]) - if test $gt_cv_c_wint_t = yes; then - AC_DEFINE([HAVE_WINT_T], [1], [Define if you have the 'wint_t' type.]) - - dnl Determine whether gnulib's or would, if present, - dnl override 'wint_t'. - AC_CACHE_CHECK([whether wint_t is large enough], - [gl_cv_type_wint_t_large_enough], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - int verify[sizeof (wint_t) < sizeof (int) ? -1 : 1]; - ]])], - [gl_cv_type_wint_t_large_enough=yes], - [gl_cv_type_wint_t_large_enough=no])]) - if test $gl_cv_type_wint_t_large_enough = no; then - GNULIBHEADERS_OVERRIDE_WINT_T=1 - else - GNULIBHEADERS_OVERRIDE_WINT_T=0 - fi - else - GNULIBHEADERS_OVERRIDE_WINT_T=0 - fi - AC_SUBST([GNULIBHEADERS_OVERRIDE_WINT_T]) -]) -m4trace:gnulib-m4/wint_t.m4:48: -1- AC_DEFUN([gl_TYPE_WINT_T_PREREQ], [ - AC_CHECK_HEADERS_ONCE([crtdefs.h]) - if test $ac_cv_header_crtdefs_h = yes; then - HAVE_CRTDEFS_H=1 - else - HAVE_CRTDEFS_H=0 - fi - AC_SUBST([HAVE_CRTDEFS_H]) -]) -m4trace:gnulib-m4/xalloc.m4:7: -1- AC_DEFUN([gl_XALLOC], [:]) -m4trace:gnulib-m4/zzgnulib.m4:23: -1- AC_DEFUN([gl_ZZGNULIB]) -m4trace:../m4/fixautomake.m4:12: -1- AC_DEFUN([FIX_MAKEFILE_DISTRIB], [ - sed -e 's,^#distdir:,distdir:,' < $ac_file > $ac_file.tmp - mv $ac_file.tmp $ac_file -]) -m4trace:../m4/fixautomake.m4:20: -1- AC_DEFUN([FIX_MAKEFILE_TOPDIR_DISTRIB], [ - sed_script='/mkdir "*\$(distdir)"*$/{a\ -\ $(MAKE) distdir1 -}' - sed -e "$sed_script" < $ac_file > $ac_file.tmp - mv $ac_file.tmp $ac_file -]) -m4trace:../m4/more-warnings.m4:12: -1- AC_DEFUN([gt_MORE_WARNINGS], [ - AC_ARG_ENABLE([more-warnings], -AS_HELP_STRING([[--enable-more-warnings]], [enable additional compiler warnings beyond -Wall]) -AS_HELP_STRING([[--disable-more-warnings]], [obey exactly the warning options specified in $CPPFLAGS $CFLAGS]), - [more_warnings=$enableval], - [dnl When to enable the warnings by default? - dnl Some other packages enable the warnings by default in a git checkout - dnl when there is no .tarball version file. This is too unreliable, since - dnl - Often the .tarball-version file is still present after the maintainer - dnl made a release or prerelease. - dnl - It is useful to see the warnings also when doing portability testing, - dnl that is, when building a tarball created by "make distcheck". - dnl Hence, use a different heuristic: Enable the warnings by default if - dnl the option -Wall is already specified. - case " $CC $CPPFLAGS $CFLAGS " in - *" -Wall "*) more_warnings=yes ;; - *) more_warnings=no ;; - esac - ]) - - dnl Warning options for production code, not including tests. - WARN_CFLAGS= - dnl Warning options for production code imported from other packages - dnl (libglib, libxml, libcroco). - FOREIGN_WARN_CFLAGS= - dnl Warning options that turn off expensive processing in the compiler. - NO_EXPENSIVE_WARN_CFLAGS= - if test "x$more_warnings" = xyes; then - dnl Add warning options. But do *not* add options that change the - dnl generated code. (That's because this code here is also in effect - dnl for distro builds.) - - dnl Set up the list of the pointless, undesired warnings. - nw= - dnl First, the warnings that are generated already with -O0: - dnl These warnings enforce a certain programming style that is not ours. - nw="$nw -Wempty-body" - nw="$nw -Wvla" - dnl All warnings produced by these options (in gcc 13) have been false - dnl alarms. - nw="$nw -Wanalyzer-double-fclose" - nw="$nw -Wanalyzer-double-free" - nw="$nw -Wanalyzer-fd-double-close" - nw="$nw -Wanalyzer-null-argument" - nw="$nw -Wanalyzer-null-dereference" - nw="$nw -Wanalyzer-use-of-uninitialized-value" - dnl This warning option is nonsense. It's normal to have to cast, for - dnl example, a 'double' to an 'int'. When that 'double' value is the - dnl result of a function call, this does not make the cast dangerous - dnl in any way. - nw="$nw -Wbad-function-cast" - dnl When we allocate memory for several objects through a single malloc() - dnl call, it's normal that we then have to cast a 'char *' to various - dnl pointer types with varying alignment. - nw="$nw -Wcast-align" - dnl We use computed format strings in a number of places, and glibc's - dnl does it as well. - nw="$nw -Wformat-nonliteral" - dnl We define a few functions for binary backward compatibility only. - dnl These functions are not declared on purpose: So that they cannot be - dnl accidentally used in new code. - nw="$nw -Wmissing-declarations" - nw="$nw -Wmissing-prototypes" - dnl We frequently have a static variable and a local variable in a function - dnl with the same name. This is normal, because the same concept often - dnl occurs in multiple locations in a file. Thus, ignore - dnl "... shadows a global declaration" warnings. Only - dnl "... shadows a parameter" and "... shadows a previous local" warnings - dnl are worth eliminating; see below. - nw="$nw -Wshadow" - dnl Too many warnings. We often use signed types like 'int' or 'idx_t' - dnl for counter variables, yet SIZEOF(array) is an unsigned value. - nw="$nw -Wsign-compare" - dnl This warning is based on older ISO C standards. It warns, in particular, - dnl about function definitions that are valid in ISO C 23 (static and - dnl non-static functions). Cf. - dnl https://lists.gnu.org/archive/html/bug-gnulib/2023-02/msg00055.html - dnl https://lore.kernel.org/distributions/2354211.7hzS34FegO@nimes/ - nw="$nw -Wold-style-definition" - dnl This warning is based on older ISO C standards. It warns, in particular, - dnl about function definitions that are valid in ISO C 23 (static functions - dnl only). Cf. - dnl https://lists.gnu.org/archive/html/bug-gnulib/2023-02/msg00055.html - dnl https://lore.kernel.org/distributions/2354211.7hzS34FegO@nimes/ - dnl https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108690 - nw="$nw -Wstrict-prototypes" - dnl There is no reason to warn about an abstract (unimplemented) method in - dnl an abstract class; it has no chance of ever being called. Only the - dnl implementations of the method on concrete subclasses can be called. - nw="$nw -Wsuggest-attribute=noreturn" - dnl There is no reason to warn about code that does not want to make - dnl assumptions about whether a certain type is signed or unsigned. - nw="$nw -Wtype-limits" - dnl Too many warnings. #if preprocessor directives often lead to unused - dnl macros. - nw="$nw -Wunused-macros" - dnl Unused parameters are frequent in functions that are meant to implement - dnl a given function type. - nw="$nw -Wunused-parameter" - dnl - dnl Next, the warnings that are generated with -O2: - dnl This warning option frequently produces false alarms. - dnl See . - nw="$nw -Wclobbered" - dnl I'm not interested in the details of which functions get inlined and - dnl which don't. - nw="$nw -Winline" - dnl Some of these warnings point to functions for which the result's - dnl destruction should be done through fclose(), _free(), etc., - dnl not free(). - nw="$nw -Wsuggest-attribute=malloc" - dnl Too many warnings. It's ridiculous that the developer should spend - dnl brain cycles on things that the compiler could often infer and which - dnl have little effect on the performance of the generated code. - dnl Cf. . - nw="$nw -Wsuggest-attribute=pure" - dnl Too many warnings. It's ridiculous that the developer should spend - dnl brain cycles on things that the compiler could often infer and which - dnl have little effect on the performance of the generated code. - dnl Cf. . - nw="$nw -Wsuggest-attribute=const" - dnl It's ridiculous that the developer should spend brain cycles on things - dnl that the compiler could often infer and which have little effect on the - dnl performance of the generated code. - nw="$nw -Wsuggest-attribute=cold" - - dnl Setup the list of meaningful warning options for the C compiler. - dnl The list comes from manywarnings.m4. Warning options that are not - dnl generally meaningful have already been filtered out (cf. - dnl build-aux/gcc-warning.spec). - gl_MANYWARN_ALL_GCC([possible_warning_options]) - - dnl Compute the list of warning options that are desired. - gl_MANYWARN_COMPLEMENT([desired_warning_options], - [$possible_warning_options], [$nw]) - dnl Compute the list of remaining undesired warning options. - dnl Namely those, that were not in manywarnings.m4 because they were - dnl already listed in build-aux/gcc-warning.spec; this includes those - dnl that are implied by -Wall. - gl_MANYWARN_COMPLEMENT([remaining_undesired_warning_options], - [$nw], [$possible_warning_options]) - - dnl Add the desired warning options to WARN_CFLAGS. - for w in $desired_warning_options; do - gl_WARN_ADD([$w]) - done - - dnl Add the opposites of the remaining undesired warning options to - dnl WARN_CFLAGS. - for w in `echo "$remaining_undesired_warning_options" | sed -e 's/-W/-Wno-/g'`; do - gl_WARN_ADD([$w]) - done - - dnl Cf. -Wshadow, above. - gl_WARN_ADD([-Wshadow=local]) - - dnl With GCC 10 and older, turn off -fanalyzer, because it requires too much - dnl memory in the compiler. - dnl See . In particular, - dnl on AIX 7.3, gcc 10.3 cannot compile regex.c with -fanalyzer: - dnl cc1: out of memory allocating 732 bytes after a total of 1072239104 bytes - AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[ - #if __GNUC__ > 10 - #error "You are lucky" - #endif - ]])], - [ - gl_WARN_ADD([-fno-analyzer]) - ]) - - dnl For production code imported from other packages, disable some other - dnl warnings. For imported code, I want to minimize difference w.r.t. - dnl upstream. - FOREIGN_WARN_CFLAGS="$WARN_CFLAGS" - fnw= - fnw="$fnw -Wcast-function-type" - fnw="$fnw -Wduplicated-cond" - fnw="$fnw -Wformat" - fnw="$fnw -Wimplicit-fallthrough" - fnw="$fnw -Wnull-dereference" - fnw="$fnw -Wsuggest-attribute=format" - for w in `echo "$fnw" | sed -e 's/-W/-Wno-/g'`; do - gl_WARN_ADD([$w], [FOREIGN_WARN_CFLAGS]) - done - - dnl Warning options that turn off expensive processing in the compiler. - gl_WARN_ADD([-fno-analyzer], [NO_EXPENSIVE_WARN_CFLAGS]) - fi - AC_SUBST([WARN_CFLAGS]) - AC_SUBST([FOREIGN_WARN_CFLAGS]) - AC_SUBST([NO_EXPENSIVE_WARN_CFLAGS]) -]) -m4trace:../m4/woe32-dll.m4:29: -1- AC_DEFUN([gl_WOE32_DLL], [ - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - mingw* | cygwin*) - AC_CACHE_CHECK([for auto-import of symbols], - [gl_cv_ld_autoimport], - [dnl --disable-auto-import is unsupported in MSVC and in MSVC/clang. - dnl We need to sort out this case explicitly, because with clang, - dnl -Wl,--disable-auto-import does not yield an error, however later - dnl libtool turns it into --disable-auto-import, which does produce - dnl an error. - AC_EGREP_CPP([Known], [ - #ifdef _MSC_VER - Known - #endif - ], - [gl_cv_ld_autoimport=no], - [gl_save_LDFLAGS="$LDFLAGS" - LDFLAGS="$LDFLAGS -Wl,--disable-auto-import" - AC_LINK_IFELSE([], [gl_cv_ld_autoimport=yes], [gl_cv_ld_autoimport=no]) - LDFLAGS="$gl_save_LDFLAGS" - ]) - ]) - if test $gl_cv_ld_autoimport = yes; then - LDFLAGS="$LDFLAGS -Wl,--disable-auto-import" - fi - ;; - esac -]) -m4trace:m4/build-to-host.m4:32: -1- AC_DEFUN([gl_BUILD_TO_HOST], [ - AC_REQUIRE([AC_CANONICAL_BUILD]) - AC_REQUIRE([AC_CANONICAL_HOST]) - AC_REQUIRE([gl_BUILD_TO_HOST_INIT]) - - dnl Define somedir_c. - gl_final_[$1]="$[$1]" - dnl Translate it from build syntax to host syntax. - case "$build_os" in - cygwin*) - case "$host_os" in - mingw* | windows*) - gl_final_[$1]=`cygpath -w "$gl_final_[$1]"` ;; - esac - ;; - esac - dnl Convert it to C string syntax. - [$1]_c=`printf '%s\n' "$gl_final_[$1]" | sed -e "$gl_sed_double_backslashes" -e "$gl_sed_escape_doublequotes" | tr -d "$gl_tr_cr"` - [$1]_c='"'"$[$1]_c"'"' - AC_SUBST([$1_c]) - - dnl Define somedir_c_make. - [$1]_c_make=`printf '%s\n' "$[$1]_c" | sed -e "$gl_sed_escape_for_make_1" -e "$gl_sed_escape_for_make_2" | tr -d "$gl_tr_cr"` - dnl Use the substituted somedir variable, when possible, so that the user - dnl may adjust somedir a posteriori when there are no special characters. - if test "$[$1]_c_make" = '\"'"${gl_final_[$1]}"'\"'; then - [$1]_c_make='\"$([$1])\"' - fi - AC_SUBST([$1_c_make]) -]) -m4trace:m4/build-to-host.m4:65: -1- AC_DEFUN([gl_BUILD_TO_HOST_INIT], [ - gl_sed_double_backslashes='s/\\/\\\\/g' - gl_sed_escape_doublequotes='s/"/\\"/g' -changequote(,)dnl - gl_sed_escape_for_make_1="s,\\([ \"&'();<>\\\\\`|]\\),\\\\\\1,g" -changequote([,])dnl - gl_sed_escape_for_make_2='s,\$,\\$$,g' - dnl Find out how to remove carriage returns from output. Solaris /usr/ucb/tr - dnl does not understand '\r'. - case `echo r | tr -d '\r'` in - '') gl_tr_cr='\015' ;; - *) gl_tr_cr='\r' ;; - esac -]) -m4trace:m4/fcntl-o.m4:14: -1- AC_DEFUN([gl_FCNTL_O_FLAGS], [ - dnl Persuade glibc to define O_NOATIME and O_NOFOLLOW. - AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) - - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - AC_CHECK_HEADERS_ONCE([unistd.h]) - AC_CHECK_FUNCS_ONCE([symlink]) - AC_CACHE_CHECK([for working fcntl.h], [gl_cv_header_working_fcntl_h], - [AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #if HAVE_UNISTD_H - # include - #else /* on Windows with MSVC */ - # include - # include - # defined sleep(n) _sleep ((n) * 1000) - #endif - #include - ]GL_MDA_DEFINES[ - #ifndef O_NOATIME - #define O_NOATIME 0 - #endif - #ifndef O_NOFOLLOW - #define O_NOFOLLOW 0 - #endif - static int const constants[] = - { - O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, O_APPEND, - O_NONBLOCK, O_SYNC, O_ACCMODE, O_RDONLY, O_RDWR, O_WRONLY - }; - ]], - [[ - int result = !constants; - #if HAVE_SYMLINK - { - static char const sym[] = "conftest.sym"; - if (symlink ("/dev/null", sym) != 0) - result |= 2; - else - { - int fd = open (sym, O_WRONLY | O_NOFOLLOW | O_CREAT, 0); - if (fd >= 0) - { - close (fd); - result |= 4; - } - } - if (unlink (sym) != 0 || symlink (".", sym) != 0) - result |= 2; - else - { - int fd = open (sym, O_RDONLY | O_NOFOLLOW); - if (fd >= 0) - { - close (fd); - result |= 4; - } - } - unlink (sym); - } - #endif - { - static char const file[] = "confdefs.h"; - int fd = open (file, O_RDONLY | O_NOATIME); - if (fd < 0) - result |= 8; - else - { - struct stat st0; - if (fstat (fd, &st0) != 0) - result |= 16; - else - { - char c; - sleep (1); - if (read (fd, &c, 1) != 1) - result |= 24; - else - { - if (close (fd) != 0) - result |= 32; - else - { - struct stat st1; - if (stat (file, &st1) != 0) - result |= 40; - else - if (st0.st_atime != st1.st_atime) - result |= 64; - } - } - } - } - } - return result;]])], - [gl_cv_header_working_fcntl_h=yes], - [case $? in #( - 4) gl_cv_header_working_fcntl_h='no (bad O_NOFOLLOW)';; #( - 64) gl_cv_header_working_fcntl_h='no (bad O_NOATIME)';; #( - 68) gl_cv_header_working_fcntl_h='no (bad O_NOATIME, O_NOFOLLOW)';; #( - *) gl_cv_header_working_fcntl_h='no';; - esac], - [case "$host_os" in - # Guess 'no' on native Windows. - mingw* | windows*) gl_cv_header_working_fcntl_h='no' ;; - *) gl_cv_header_working_fcntl_h=cross-compiling ;; - esac - ]) - ]) - - case $gl_cv_header_working_fcntl_h in #( - *O_NOATIME* | no | cross-compiling) ac_val=0;; #( - *) ac_val=1;; - esac - AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOATIME], [$ac_val], - [Define to 1 if O_NOATIME works.]) - - case $gl_cv_header_working_fcntl_h in #( - *O_NOFOLLOW* | no | cross-compiling) ac_val=0;; #( - *) ac_val=1;; - esac - AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOFOLLOW], [$ac_val], - [Define to 1 if O_NOFOLLOW works.]) -]) -m4trace:m4/flexmember.m4:11: -1- AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER], [ - AC_CACHE_CHECK([for flexible array member], - ac_cv_c_flexmember, - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[#include - #include - #include - struct m { struct m *next, **list; char name[]; }; - struct s { struct s *p; struct m *m; int n; double d[]; };]], - [[int m = getchar (); - size_t nbytes = offsetof (struct s, d) + m * sizeof (double); - nbytes += sizeof (struct s) - 1; - nbytes -= nbytes % sizeof (struct s); - struct s *p = malloc (nbytes); - p->p = p; - p->m = NULL; - p->d[0] = 0.0; - return p->d != (double *) NULL;]])], - [ac_cv_c_flexmember=yes], - [ac_cv_c_flexmember=no])]) - if test $ac_cv_c_flexmember = yes; then - AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], - [Define to nothing if C supports flexible array members, and to - 1 if it does not. That way, with a declaration like 'struct s - { int n; short d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack - can be used with pre-C99 compilers. - Use 'FLEXSIZEOF (struct s, d, N * sizeof (short))' to calculate - the size in bytes of such a struct containing an N-element array.]) - else - AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1]) - fi -]) -m4trace:m4/gettext.m4:57: -1- AC_DEFUN([AM_GNU_GETTEXT], [ - dnl Argument checking. - m4_if([$1], [], , [m4_if([$1], [external], , [m4_if([$1], [use-libtool], , [m4_if([$1], [here], , - [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT -])])])])]) - m4_if(m4_if([$1], [], [old])[]m4_if([$1], [no-libtool], [old]), [old], - [errprint([ERROR: Use of AM_GNU_GETTEXT without [external] argument is no longer supported. -])]) - m4_if([$2], [], , [m4_if([$2], [need-ngettext], , [m4_if([$2], [need-formatstring-macros], , - [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT -])])])]) - define([gt_building_libintl_in_same_build_tree], - m4_if([$1], [use-libtool], [yes], [m4_if([$1], [here], [yes], [no])])) - gt_NEEDS_INIT - AM_GNU_GETTEXT_NEED([$2]) - - AC_REQUIRE([AM_PO_SUBDIRS])dnl - - dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. - AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) - AC_REQUIRE([AC_LIB_RPATH]) - - dnl Sometimes libintl requires libiconv, so first search for libiconv. - dnl Ideally we would do this search only after the - dnl if test "$USE_NLS" = "yes"; then - dnl if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then - dnl tests. But if configure.ac invokes AM_ICONV after AM_GNU_GETTEXT - dnl the configure script would need to contain the same shell code - dnl again, outside any 'if'. There are two solutions: - dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. - dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. - dnl Since AC_PROVIDE_IFELSE is not documented, we avoid it. - m4_if(gt_building_libintl_in_same_build_tree, yes, , [ - AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) - ]) - - dnl Sometimes, on Mac OS X, libintl requires linking with CoreFoundation. - gt_INTL_MACOSX - - dnl Set USE_NLS. - AC_REQUIRE([AM_NLS]) - - m4_if(gt_building_libintl_in_same_build_tree, yes, [ - USE_INCLUDED_LIBINTL=no - ]) - LIBINTL= - LTLIBINTL= - POSUB= - - dnl Add a version number to the cache macros. - case " $gt_needs " in - *" need-formatstring-macros "*) gt_api_version=3 ;; - *" need-ngettext "*) gt_api_version=2 ;; - *) gt_api_version=1 ;; - esac - gt_func_gnugettext_libc="gt_cv_func_gnugettext${gt_api_version}_libc" - gt_func_gnugettext_libintl="gt_cv_func_gnugettext${gt_api_version}_libintl" - - dnl If we use NLS figure out what method - if test "$USE_NLS" = "yes"; then - gt_use_preinstalled_gnugettext=no - m4_if(gt_building_libintl_in_same_build_tree, yes, [ - AC_MSG_CHECKING([whether included gettext is requested]) - AC_ARG_WITH([included-gettext], - [ --with-included-gettext use the GNU gettext library included here], - nls_cv_force_use_gnu_gettext=$withval, - nls_cv_force_use_gnu_gettext=no) - AC_MSG_RESULT([$nls_cv_force_use_gnu_gettext]) - - nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" - if test "$nls_cv_force_use_gnu_gettext" != "yes"; then - ]) - dnl User does not insist on using GNU NLS library. Figure out what - dnl to use. If GNU gettext is available we use this. Else we have - dnl to fall back to GNU NLS library. - - if test $gt_api_version -ge 3; then - gt_revision_test_code=' -#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) -#endif -changequote(,)dnl -typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; -changequote([,])dnl -' - else - gt_revision_test_code= - fi - if test $gt_api_version -ge 2; then - gt_expression_test_code=' + * ngettext ("", "", 0)' - else - gt_expression_test_code= - fi - - AC_CACHE_CHECK([for GNU gettext in libc], [$gt_func_gnugettext_libc], - [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -extern int _nl_msg_cat_cntr; -extern int *_nl_domain_bindings; -#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_domain_bindings) -#else -#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 -#endif -$gt_revision_test_code - ]], - [[ -bindtextdomain ("", ""); -return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION - ]])], - [eval "$gt_func_gnugettext_libc=yes"], - [eval "$gt_func_gnugettext_libc=no"])]) - - if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then - dnl Sometimes libintl requires libiconv, so first search for libiconv. - m4_if(gt_building_libintl_in_same_build_tree, yes, , [ - AM_ICONV_LINK - ]) - dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL - dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) - dnl because that would add "-liconv" to LIBINTL and LTLIBINTL - dnl even if libiconv doesn't exist. - AC_LIB_LINKFLAGS_BODY([intl]) - AC_CACHE_CHECK([for GNU gettext in libintl], - [$gt_func_gnugettext_libintl], - [gt_save_CPPFLAGS="$CPPFLAGS" - CPPFLAGS="$CPPFLAGS $INCINTL" - gt_save_LIBS="$LIBS" - LIBS="$LIBS $LIBINTL" - dnl Now see whether libintl exists and does not depend on libiconv. - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -extern int _nl_msg_cat_cntr; -extern -#ifdef __cplusplus -"C" -#endif -const char *_nl_expand_alias (const char *); -#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) -#else -#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 -#endif -$gt_revision_test_code - ]], - [[ -bindtextdomain ("", ""); -return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION - ]])], - [eval "$gt_func_gnugettext_libintl=yes"], - [eval "$gt_func_gnugettext_libintl=no"]) - dnl Now see whether libintl exists and depends on libiconv or other - dnl OS dependent libraries, specifically on macOS and AIX. - gt_LIBINTL_EXTRA="$INTL_MACOSX_LIBS" - AC_REQUIRE([AC_CANONICAL_HOST]) - case "$host_os" in - aix*) gt_LIBINTL_EXTRA="-lpthread" ;; - esac - if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" != yes; } \ - && { test -n "$LIBICONV" || test -n "$gt_LIBINTL_EXTRA"; }; then - LIBS="$LIBS $LIBICONV $gt_LIBINTL_EXTRA" - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#ifndef __GNU_GETTEXT_SUPPORTED_REVISION -extern int _nl_msg_cat_cntr; -extern -#ifdef __cplusplus -"C" -#endif -const char *_nl_expand_alias (const char *); -#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) -#else -#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 -#endif -$gt_revision_test_code - ]], - [[ -bindtextdomain ("", ""); -return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION - ]])], - [LIBINTL="$LIBINTL $LIBICONV $gt_LIBINTL_EXTRA" - LTLIBINTL="$LTLIBINTL $LTLIBICONV $gt_LIBINTL_EXTRA" - eval "$gt_func_gnugettext_libintl=yes" - ]) - fi - CPPFLAGS="$gt_save_CPPFLAGS" - LIBS="$gt_save_LIBS"]) - fi - - dnl If an already present or preinstalled GNU gettext() is found, - dnl use it. But if this macro is used in GNU gettext, and GNU - dnl gettext is already preinstalled in libintl, we update this - dnl libintl. (Cf. the install rule in intl/Makefile.in.) - if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \ - || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \ - && test "$PACKAGE" != gettext-runtime \ - && test "$PACKAGE" != gettext-tools \ - && test "$PACKAGE" != libintl; }; then - gt_use_preinstalled_gnugettext=yes - else - dnl Reset the values set by searching for libintl. - LIBINTL= - LTLIBINTL= - INCINTL= - fi - - m4_if(gt_building_libintl_in_same_build_tree, yes, [ - if test "$gt_use_preinstalled_gnugettext" != "yes"; then - dnl GNU gettext is not found in the C library. - dnl Fall back on included GNU gettext library. - nls_cv_use_gnu_gettext=yes - fi - fi - - if test "$nls_cv_use_gnu_gettext" = "yes"; then - dnl Mark actions used to generate GNU NLS library. - USE_INCLUDED_LIBINTL=yes - LIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LIBICONV $LIBTHREAD" - LTLIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LTLIBICONV $LTLIBTHREAD" - LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` - fi - - CATOBJEXT= - if test "$gt_use_preinstalled_gnugettext" = "yes" \ - || test "$nls_cv_use_gnu_gettext" = "yes"; then - dnl Mark actions to use GNU gettext tools. - CATOBJEXT=.gmo - fi - ]) - - if test -n "$INTL_MACOSX_LIBS"; then - if test "$gt_use_preinstalled_gnugettext" = "yes" \ - || test "$nls_cv_use_gnu_gettext" = "yes"; then - dnl Some extra flags are needed during linking. - LIBINTL="$LIBINTL $INTL_MACOSX_LIBS" - LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS" - fi - fi - - if test "$gt_use_preinstalled_gnugettext" = "yes" \ - || test "$nls_cv_use_gnu_gettext" = "yes"; then - AC_DEFINE([ENABLE_NLS], [1], - [Define to 1 if translation of program messages to the user's native language - is requested.]) - else - USE_NLS=no - fi - fi - - AC_MSG_CHECKING([whether to use NLS]) - AC_MSG_RESULT([$USE_NLS]) - if test "$USE_NLS" = "yes"; then - AC_MSG_CHECKING([where the gettext function comes from]) - if test "$gt_use_preinstalled_gnugettext" = "yes"; then - if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then - gt_source="external libintl" - else - gt_source="libc" - fi - else - gt_source="included intl directory" - fi - AC_MSG_RESULT([$gt_source]) - fi - - if test "$USE_NLS" = "yes"; then - - if test "$gt_use_preinstalled_gnugettext" = "yes"; then - if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then - AC_MSG_CHECKING([how to link with libintl]) - AC_MSG_RESULT([$LIBINTL]) - AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) - fi - - dnl For backward compatibility. Some packages may be using this. - AC_DEFINE([HAVE_GETTEXT], [1], - [Define if the GNU gettext() function is already present or preinstalled.]) - AC_DEFINE([HAVE_DCGETTEXT], [1], - [Define if the GNU dcgettext() function is already present or preinstalled.]) - fi - - dnl We need to process the po/ directory. - POSUB=po - fi - - m4_if(gt_building_libintl_in_same_build_tree, yes, [ - dnl Make all variables we use known to autoconf. - AC_SUBST([USE_INCLUDED_LIBINTL]) - AC_SUBST([CATOBJEXT]) - ]) - - m4_if(gt_building_libintl_in_same_build_tree, yes, [], [ - dnl For backward compatibility. Some Makefiles may be using this. - INTLLIBS="$LIBINTL" - AC_SUBST([INTLLIBS]) - ]) - - dnl Make all documented variables known to autoconf. - AC_SUBST([LIBINTL]) - AC_SUBST([LTLIBINTL]) - AC_SUBST([POSUB]) - - dnl Define localedir_c and localedir_c_make. - dnl Find the final value of localedir. - gt_save_prefix="${prefix}" - gt_save_datarootdir="${datarootdir}" - gt_save_localedir="${localedir}" - dnl Unfortunately, prefix gets only finally determined at the end of - dnl configure. - if test "X$prefix" = "XNONE"; then - prefix="$ac_default_prefix" - fi - eval datarootdir="$datarootdir" - eval localedir="$localedir" - gl_BUILD_TO_HOST([localedir]) - localedir="${gt_save_localedir}" - datarootdir="${gt_save_datarootdir}" - prefix="${gt_save_prefix}" -]) -m4trace:m4/gettext.m4:394: -1- AC_DEFUN([AM_GNU_GETTEXT_NEED], [ - m4_divert_text([INIT_PREPARE], [gt_needs="$gt_needs $1"]) -]) -m4trace:m4/gettext.m4:401: -1- AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) -m4trace:m4/gettext.m4:405: -1- AC_DEFUN([AM_GNU_GETTEXT_REQUIRE_VERSION], []) -m4trace:m4/iconv.m4:16: -1- AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], [ - dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. - AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) - AC_REQUIRE([AC_LIB_RPATH]) - - dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV - dnl accordingly. - AC_LIB_LINKFLAGS_BODY([iconv]) -]) -m4trace:m4/iconv.m4:27: -1- AC_DEFUN([AM_ICONV_LINK], [ - dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and - dnl those with the standalone portable GNU libiconv installed). - AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles - - dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV - dnl accordingly. - AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) - - dnl Add $INCICONV to CPPFLAGS before performing the following checks, - dnl because if the user has installed libiconv and not disabled its use - dnl via --without-libiconv-prefix, he wants to use it. The first - dnl AC_LINK_IFELSE will then fail, the second AC_LINK_IFELSE will succeed. - gl_saved_CPPFLAGS="$CPPFLAGS" - AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) - - AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [ - am_cv_func_iconv="no, consider installing GNU libiconv" - am_cv_lib_iconv=no - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#include - ]], - [[iconv_t cd = iconv_open("",""); - iconv(cd,NULL,NULL,NULL,NULL); - iconv_close(cd);]])], - [am_cv_func_iconv=yes]) - if test "$am_cv_func_iconv" != yes; then - gl_saved_LIBS="$LIBS" - LIBS="$LIBS $LIBICONV" - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#include - ]], - [[iconv_t cd = iconv_open("",""); - iconv(cd,NULL,NULL,NULL,NULL); - iconv_close(cd);]])], - [am_cv_lib_iconv=yes] - [am_cv_func_iconv=yes]) - LIBS="$gl_saved_LIBS" - fi - ]) - if test "$am_cv_func_iconv" = yes; then - AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [ - dnl This tests against bugs in AIX 5.1, AIX 6.1..7.1, HP-UX 11.11, - dnl Solaris 10. - gl_saved_LIBS="$LIBS" - if test $am_cv_lib_iconv = yes; then - LIBS="$LIBS $LIBICONV" - fi - am_cv_func_iconv_works=no - for ac_iconv_const in '' 'const'; do - AC_RUN_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#include - -#ifndef ICONV_CONST -# define ICONV_CONST $ac_iconv_const -#endif - ]], - [[int result = 0; - /* Test against AIX 5.1...7.2 bug: Failures are not distinguishable from - successful returns. This is even documented in - */ - { - iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8"); - if (cd_utf8_to_88591 != (iconv_t)(-1)) - { - static ICONV_CONST char input[] = "\342\202\254"; /* EURO SIGN */ - char buf[10]; - ICONV_CONST char *inptr = input; - size_t inbytesleft = strlen (input); - char *outptr = buf; - size_t outbytesleft = sizeof (buf); - size_t res = iconv (cd_utf8_to_88591, - &inptr, &inbytesleft, - &outptr, &outbytesleft); - if (res == 0) - result |= 1; - iconv_close (cd_utf8_to_88591); - } - } - /* Test against Solaris 10 bug: Failures are not distinguishable from - successful returns. */ - { - iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646"); - if (cd_ascii_to_88591 != (iconv_t)(-1)) - { - static ICONV_CONST char input[] = "\263"; - char buf[10]; - ICONV_CONST char *inptr = input; - size_t inbytesleft = strlen (input); - char *outptr = buf; - size_t outbytesleft = sizeof (buf); - size_t res = iconv (cd_ascii_to_88591, - &inptr, &inbytesleft, - &outptr, &outbytesleft); - if (res == 0) - result |= 2; - iconv_close (cd_ascii_to_88591); - } - } - /* Test against AIX 6.1..7.1 bug: Buffer overrun. */ - { - iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1"); - if (cd_88591_to_utf8 != (iconv_t)(-1)) - { - static ICONV_CONST char input[] = "\304"; - static char buf[2] = { (char)0xDE, (char)0xAD }; - ICONV_CONST char *inptr = input; - size_t inbytesleft = 1; - char *outptr = buf; - size_t outbytesleft = 1; - size_t res = iconv (cd_88591_to_utf8, - &inptr, &inbytesleft, - &outptr, &outbytesleft); - if (res != (size_t)(-1) || outptr - buf > 1 || buf[1] != (char)0xAD) - result |= 4; - iconv_close (cd_88591_to_utf8); - } - } -#if 0 /* This bug could be worked around by the caller. */ - /* Test against HP-UX 11.11 bug: Positive return value instead of 0. */ - { - iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591"); - if (cd_88591_to_utf8 != (iconv_t)(-1)) - { - static ICONV_CONST char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337"; - char buf[50]; - ICONV_CONST char *inptr = input; - size_t inbytesleft = strlen (input); - char *outptr = buf; - size_t outbytesleft = sizeof (buf); - size_t res = iconv (cd_88591_to_utf8, - &inptr, &inbytesleft, - &outptr, &outbytesleft); - if ((int)res > 0) - result |= 8; - iconv_close (cd_88591_to_utf8); - } - } -#endif - /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is - provided. */ - { - /* Try standardized names. */ - iconv_t cd1 = iconv_open ("UTF-8", "EUC-JP"); - /* Try IRIX, OSF/1 names. */ - iconv_t cd2 = iconv_open ("UTF-8", "eucJP"); - /* Try AIX names. */ - iconv_t cd3 = iconv_open ("UTF-8", "IBM-eucJP"); - /* Try HP-UX names. */ - iconv_t cd4 = iconv_open ("utf8", "eucJP"); - if (cd1 == (iconv_t)(-1) && cd2 == (iconv_t)(-1) - && cd3 == (iconv_t)(-1) && cd4 == (iconv_t)(-1)) - result |= 16; - if (cd1 != (iconv_t)(-1)) - iconv_close (cd1); - if (cd2 != (iconv_t)(-1)) - iconv_close (cd2); - if (cd3 != (iconv_t)(-1)) - iconv_close (cd3); - if (cd4 != (iconv_t)(-1)) - iconv_close (cd4); - } - return result; -]])], - [am_cv_func_iconv_works=yes], , - [case "$host_os" in - aix* | hpux*) am_cv_func_iconv_works="guessing no" ;; - *) am_cv_func_iconv_works="guessing yes" ;; - esac]) - test "$am_cv_func_iconv_works" = no || break - done - LIBS="$gl_saved_LIBS" - ]) - case "$am_cv_func_iconv_works" in - *no) am_func_iconv=no am_cv_lib_iconv=no ;; - *) am_func_iconv=yes ;; - esac - else - am_func_iconv=no am_cv_lib_iconv=no - fi - if test "$am_func_iconv" = yes; then - AC_DEFINE([HAVE_ICONV], [1], - [Define if you have the iconv() function and it works.]) - fi - if test "$am_cv_lib_iconv" = yes; then - AC_MSG_CHECKING([how to link with libiconv]) - AC_MSG_RESULT([$LIBICONV]) - else - dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV - dnl either. - CPPFLAGS="$gl_saved_CPPFLAGS" - LIBICONV= - LTLIBICONV= - fi - AC_SUBST([LIBICONV]) - AC_SUBST([LTLIBICONV]) -]) -m4trace:m4/iconv.m4:237: -1- AC_DEFUN_ONCE([AM_ICONV], [ - AM_ICONV_LINK - if test "$am_cv_func_iconv" = yes; then - AC_CACHE_CHECK([whether iconv is compatible with its POSIX signature], - [gl_cv_iconv_nonconst], - [AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[ -#include -#include -extern -#ifdef __cplusplus -"C" -#endif -size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); - ]], - [[]])], - [gl_cv_iconv_nonconst=yes], - [gl_cv_iconv_nonconst=no]) - ]) - else - dnl When compiling GNU libiconv on a system that does not have iconv yet, - dnl pick the POSIX compliant declaration without 'const'. - gl_cv_iconv_nonconst=yes - fi - if test $gl_cv_iconv_nonconst = yes; then - iconv_arg1="" - else - iconv_arg1="const" - fi - AC_DEFINE_UNQUOTED([ICONV_CONST], [$iconv_arg1], - [Define as const if the declaration of iconv() needs const.]) - dnl Also substitute ICONV_CONST in the gnulib generated . - m4_ifdef([gl_ICONV_H_DEFAULTS], - [AC_REQUIRE([gl_ICONV_H_DEFAULTS]) - if test $gl_cv_iconv_nonconst != yes; then - ICONV_CONST="const" - fi - ]) - - dnl A summary result, for those packages which want to print a summary at the - dnl end of the configuration. - if test "$am_func_iconv" = yes; then - if test -n "$LIBICONV"; then - am_cv_func_iconv_summary='yes, in libiconv' - else - am_cv_func_iconv_summary='yes, in libc' - fi - else - if test "$am_cv_func_iconv" = yes; then - am_cv_func_iconv_summary='not working, consider installing GNU libiconv' - else - am_cv_func_iconv_summary='no, consider installing GNU libiconv' - fi - fi -]) -m4trace:m4/intlmacosx.m4:18: -1- AC_DEFUN([gt_INTL_MACOSX], [ - dnl Check for API introduced in Mac OS X 10.4. - AC_CACHE_CHECK([for CFPreferencesCopyAppValue], - [gt_cv_func_CFPreferencesCopyAppValue], - [gt_saved_LIBS="$LIBS" - LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[CFPreferencesCopyAppValue(NULL, NULL)]])], - [gt_cv_func_CFPreferencesCopyAppValue=yes], - [gt_cv_func_CFPreferencesCopyAppValue=no]) - LIBS="$gt_saved_LIBS"]) - if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then - AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1], - [Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in the CoreFoundation framework.]) - fi - dnl Don't check for the API introduced in Mac OS X 10.5, CFLocaleCopyCurrent, - dnl because in macOS 10.13.4 it has the following behaviour: - dnl When two or more languages are specified in the - dnl "System Preferences > Language & Region > Preferred Languages" panel, - dnl it returns en_CC where CC is the territory (even when English is not among - dnl the preferred languages!). What we want instead is what - dnl CFLocaleCopyCurrent returned in earlier macOS releases and what - dnl CFPreferencesCopyAppValue still returns, namely ll_CC where ll is the - dnl first among the preferred languages and CC is the territory. - AC_CACHE_CHECK([for CFLocaleCopyPreferredLanguages], [gt_cv_func_CFLocaleCopyPreferredLanguages], - [gt_saved_LIBS="$LIBS" - LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" - AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include ]], - [[CFLocaleCopyPreferredLanguages();]])], - [gt_cv_func_CFLocaleCopyPreferredLanguages=yes], - [gt_cv_func_CFLocaleCopyPreferredLanguages=no]) - LIBS="$gt_saved_LIBS"]) - if test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then - AC_DEFINE([HAVE_CFLOCALECOPYPREFERREDLANGUAGES], [1], - [Define to 1 if you have the Mac OS X function CFLocaleCopyPreferredLanguages in the CoreFoundation framework.]) - fi - INTL_MACOSX_LIBS= - if test $gt_cv_func_CFPreferencesCopyAppValue = yes \ - || test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then - dnl Starting with macOS version 14, CoreFoundation relies on CoreServices, - dnl and we have to link it in explicitly, otherwise an exception - dnl NSInvalidArgumentException "unrecognized selector sent to instance" - dnl occurs. - INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation -Wl,-framework -Wl,CoreServices" - fi - AC_SUBST([INTL_MACOSX_LIBS]) -]) -m4trace:m4/nls.m4:23: -1- AC_DEFUN([AM_NLS], [ - AC_MSG_CHECKING([whether NLS is requested]) - dnl Default is enabled NLS - AC_ARG_ENABLE([nls], - [ --disable-nls do not use Native Language Support], - USE_NLS=$enableval, USE_NLS=yes) - AC_MSG_RESULT([$USE_NLS]) - AC_SUBST([USE_NLS]) -]) -m4trace:m4/po.m4:24: -1- AC_DEFUN([AM_PO_SUBDIRS], [ - AC_REQUIRE([AC_PROG_MAKE_SET])dnl - AC_REQUIRE([AC_PROG_INSTALL])dnl - AC_REQUIRE([AC_PROG_MKDIR_P])dnl - AC_REQUIRE([AC_PROG_SED])dnl - AC_REQUIRE([AM_NLS])dnl - - dnl Release version of the gettext macros. This is used to ensure that - dnl the gettext macros and po/Makefile.in.in are in sync. - AC_SUBST([GETTEXT_MACRO_VERSION], [0.20]) - - dnl Perform the following tests also if --disable-nls has been given, - dnl because they are needed for "make dist" to work. - - dnl Search for GNU msgfmt in the PATH. - dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. - dnl The second test excludes FreeBSD msgfmt. - AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, - [$ac_dir/$ac_word --statistics /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && - (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], - :) - AC_PATH_PROG([GMSGFMT], [gmsgfmt], [$MSGFMT]) - - dnl Test whether it is GNU msgfmt >= 0.15. -changequote(,)dnl - case `$GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in - '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) GMSGFMT_015=: ;; - *) GMSGFMT_015=$GMSGFMT ;; - esac -changequote([,])dnl - AC_SUBST([GMSGFMT_015]) - - dnl Search for GNU xgettext 0.12 or newer in the PATH. - dnl The first test excludes Solaris xgettext and early GNU xgettext versions. - dnl The second test excludes FreeBSD xgettext. - AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, - [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && - (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], - :) - dnl Remove leftover from FreeBSD xgettext call. - rm -f messages.po - - dnl Test whether it is GNU xgettext >= 0.15. -changequote(,)dnl - case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in - '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;; - *) XGETTEXT_015=$XGETTEXT ;; - esac -changequote([,])dnl - AC_SUBST([XGETTEXT_015]) - - dnl Search for GNU msgmerge 0.11 or newer in the PATH. - AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, - [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :) - - dnl Test whether it is GNU msgmerge >= 0.20. - if LC_ALL=C $MSGMERGE --help | grep ' --for-msgfmt ' >/dev/null; then - MSGMERGE_FOR_MSGFMT_OPTION='--for-msgfmt' - else - dnl Test whether it is GNU msgmerge >= 0.12. - if LC_ALL=C $MSGMERGE --help | grep ' --no-fuzzy-matching ' >/dev/null; then - MSGMERGE_FOR_MSGFMT_OPTION='--no-fuzzy-matching --no-location --quiet' - else - dnl With these old versions, $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) is - dnl slow. But this is not a big problem, as such old gettext versions are - dnl hardly in use any more. - MSGMERGE_FOR_MSGFMT_OPTION='--no-location --quiet' - fi - fi - AC_SUBST([MSGMERGE_FOR_MSGFMT_OPTION]) - - dnl Support for AM_XGETTEXT_OPTION. - test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS= - AC_SUBST([XGETTEXT_EXTRA_OPTIONS]) - - AC_CONFIG_COMMANDS([po-directories], [[ - for ac_file in $CONFIG_FILES; do - # Support "outfile[:infile[:infile...]]" - case "$ac_file" in - *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; - esac - # PO directories have a Makefile.in generated from Makefile.in.in. - case "$ac_file" in */Makefile.in) - # Adjust a relative srcdir. - ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` - ac_dir_suffix=/`echo "$ac_dir"|sed 's%^\./%%'` - ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` - # In autoconf-2.13 it is called $ac_given_srcdir. - # In autoconf-2.50 it is called $srcdir. - test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" - case "$ac_given_srcdir" in - .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; - /*) top_srcdir="$ac_given_srcdir" ;; - *) top_srcdir="$ac_dots$ac_given_srcdir" ;; - esac - # Treat a directory as a PO directory if and only if it has a - # POTFILES.in file. This allows packages to have multiple PO - # directories under different names or in different locations. - if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then - rm -f "$ac_dir/POTFILES" - test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES" - gt_tab=`printf '\t'` - cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ${gt_tab}]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES" - POMAKEFILEDEPS="POTFILES.in" - # ALL_LINGUAS, POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES depend - # on $ac_dir but don't depend on user-specified configuration - # parameters. - if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then - # The LINGUAS file contains the set of available languages. - if test -n "$OBSOLETE_ALL_LINGUAS"; then - test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" - fi - ALL_LINGUAS=`sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS"` - POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS" - else - # The set of available languages was given in configure.in. - ALL_LINGUAS=$OBSOLETE_ALL_LINGUAS - fi - # Compute POFILES - # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po) - # Compute UPDATEPOFILES - # as $(foreach lang, $(ALL_LINGUAS), $(lang).po-update) - # Compute DUMMYPOFILES - # as $(foreach lang, $(ALL_LINGUAS), $(lang).nop) - # Compute GMOFILES - # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo) - case "$ac_given_srcdir" in - .) srcdirpre= ;; - *) srcdirpre='$(srcdir)/' ;; - esac - POFILES= - UPDATEPOFILES= - DUMMYPOFILES= - GMOFILES= - for lang in $ALL_LINGUAS; do - POFILES="$POFILES $srcdirpre$lang.po" - UPDATEPOFILES="$UPDATEPOFILES $lang.po-update" - DUMMYPOFILES="$DUMMYPOFILES $lang.nop" - GMOFILES="$GMOFILES $srcdirpre$lang.gmo" - done - # CATALOGS depends on both $ac_dir and the user's LINGUAS - # environment variable. - INST_LINGUAS= - if test -n "$ALL_LINGUAS"; then - for presentlang in $ALL_LINGUAS; do - useit=no - if test "%UNSET%" != "$LINGUAS"; then - desiredlanguages="$LINGUAS" - else - desiredlanguages="$ALL_LINGUAS" - fi - for desiredlang in $desiredlanguages; do - # Use the presentlang catalog if desiredlang is - # a. equal to presentlang, or - # b. a variant of presentlang (because in this case, - # presentlang can be used as a fallback for messages - # which are not translated in the desiredlang catalog). - case "$desiredlang" in - "$presentlang" | "$presentlang"_* | "$presentlang".* | "$presentlang"@*) - useit=yes - ;; - esac - done - if test $useit = yes; then - INST_LINGUAS="$INST_LINGUAS $presentlang" - fi - done - fi - CATALOGS= - if test -n "$INST_LINGUAS"; then - for lang in $INST_LINGUAS; do - CATALOGS="$CATALOGS $lang.gmo" - done - fi - test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" - sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile" - for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do - if test -f "$f"; then - case "$f" in - *.orig | *.bak | *~) ;; - *) cat "$f" >> "$ac_dir/Makefile" ;; - esac - fi - done - fi - ;; - esac - done]], - [# Capture the value of obsolete ALL_LINGUAS because we need it to compute - # POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES, CATALOGS. - OBSOLETE_ALL_LINGUAS="$ALL_LINGUAS" - # Capture the value of LINGUAS because we need it to compute CATALOGS. - LINGUAS="${LINGUAS-%UNSET%}" - ]) -]) -m4trace:m4/po.m4:222: -1- AC_DEFUN([AM_POSTPROCESS_PO_MAKEFILE], [ - # When this code is run, in config.status, two variables have already been - # set: - # - OBSOLETE_ALL_LINGUAS is the value of LINGUAS set in configure.in, - # - LINGUAS is the value of the environment variable LINGUAS at configure - # time. - -changequote(,)dnl - # Adjust a relative srcdir. - ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` - ac_dir_suffix=/`echo "$ac_dir"|sed 's%^\./%%'` - ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` - # In autoconf-2.13 it is called $ac_given_srcdir. - # In autoconf-2.50 it is called $srcdir. - test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" - case "$ac_given_srcdir" in - .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; - /*) top_srcdir="$ac_given_srcdir" ;; - *) top_srcdir="$ac_dots$ac_given_srcdir" ;; - esac - - # Find a way to echo strings without interpreting backslash. - if test "X`(echo '\t') 2>/dev/null`" = 'X\t'; then - gt_echo='echo' - else - if test "X`(printf '%s\n' '\t') 2>/dev/null`" = 'X\t'; then - gt_echo='printf %s\n' - else - echo_func () { - cat < "$ac_file.tmp" - tab=`printf '\t'` - if grep -l '@TCLCATALOGS@' "$ac_file" > /dev/null; then - # Add dependencies that cannot be formulated as a simple suffix rule. - for lang in $ALL_LINGUAS; do - frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'` - cat >> "$ac_file.tmp" < /dev/null; then - # Add dependencies that cannot be formulated as a simple suffix rule. - for lang in $ALL_LINGUAS; do - frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'` - cat >> "$ac_file.tmp" <> "$ac_file.tmp" </dev/null 2>&1 \ - && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ - || PATH_SEPARATOR=';' - } -fi - -# Find out how to test for executable files. Don't use a zero-byte file, -# as systems may use methods other than mode bits to determine executability. -cat >conf$$.file <<_ASEOF -#! /bin/sh -exit 0 -_ASEOF -chmod +x conf$$.file -if test -x conf$$.file >/dev/null 2>&1; then - ac_executable_p="test -x" -else - ac_executable_p="test -f" -fi -rm -f conf$$.file - -# Extract the first word of "$2", so it can be a program name with args. -set dummy $2; ac_word=[$]2 -AC_MSG_CHECKING([for $ac_word]) -AC_CACHE_VAL([ac_cv_path_$1], -[case "[$]$1" in - [[\\/]]* | ?:[[\\/]]*) - ac_cv_path_$1="[$]$1" # Let the user override the test with a path. - ;; - *) - gt_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR - for ac_dir in m4_if([$5], , $PATH, [$5]); do - IFS="$gt_saved_IFS" - test -z "$ac_dir" && ac_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then - echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD - if [$3]; then - ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext" - break 2 - fi - fi - done - done - IFS="$gt_saved_IFS" -dnl If no 4th arg is given, leave the cache variable unset, -dnl so AC_PATH_PROGS will keep looking. -m4_if([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" -])dnl - ;; -esac])dnl -$1="$ac_cv_path_$1" -if test m4_if([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then - AC_MSG_RESULT([$][$1]) -else - AC_MSG_RESULT([no]) -fi -AC_SUBST([$1])dnl -]) -m4trace:m4/visibility.m4:23: -1- AC_DEFUN([gl_VISIBILITY], [ - AC_REQUIRE([AC_PROG_CC]) - CFLAG_VISIBILITY= - HAVE_VISIBILITY=0 - if test -n "$GCC"; then - dnl First, check whether -Werror can be added to the command line, or - dnl whether it leads to an error because of some other option that the - dnl user has put into $CC $CFLAGS $CPPFLAGS. - AC_CACHE_CHECK([whether the -Werror option is usable], - [gl_cv_cc_vis_werror], - [gl_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -Werror" - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM([[]], [[]])], - [gl_cv_cc_vis_werror=yes], - [gl_cv_cc_vis_werror=no]) - CFLAGS="$gl_save_CFLAGS" - ]) - dnl Now check whether visibility declarations are supported. - AC_CACHE_CHECK([for simple visibility declarations], - [gl_cv_cc_visibility], - [gl_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS -fvisibility=hidden" - dnl We use the option -Werror and a function dummyfunc, because on some - dnl platforms (Cygwin 1.7) the use of -fvisibility triggers a warning - dnl "visibility attribute not supported in this configuration; ignored" - dnl at the first function definition in every compilation unit, and we - dnl don't want to use the option in this case. - if test $gl_cv_cc_vis_werror = yes; then - CFLAGS="$CFLAGS -Werror" - fi - AC_COMPILE_IFELSE( - [AC_LANG_PROGRAM( - [[extern __attribute__((__visibility__("hidden"))) int hiddenvar; - extern __attribute__((__visibility__("default"))) int exportedvar; - extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void); - extern __attribute__((__visibility__("default"))) int exportedfunc (void); - void dummyfunc (void) {} - ]], - [[]])], - [gl_cv_cc_visibility=yes], - [gl_cv_cc_visibility=no]) - CFLAGS="$gl_save_CFLAGS" - ]) - if test $gl_cv_cc_visibility = yes; then - CFLAG_VISIBILITY="-fvisibility=hidden" - HAVE_VISIBILITY=1 - fi - fi - AC_SUBST([CFLAG_VISIBILITY]) - AC_SUBST([HAVE_VISIBILITY]) - AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY], - [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:62: -1- AC_DEFUN([LT_INIT], [AC_PREREQ([2.64])dnl We use AC_PATH_PROGS_FEATURE_CHECK -AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl -AC_BEFORE([$0], [LT_LANG])dnl -AC_BEFORE([$0], [LT_OUTPUT])dnl -AC_BEFORE([$0], [LTDL_INIT])dnl -m4_require([_LT_CHECK_BUILDDIR])dnl - -dnl Autoconf doesn't catch unexpanded LT_ macros by default: -m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl -m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl -dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 -dnl unless we require an AC_DEFUNed macro: -AC_REQUIRE([LTOPTIONS_VERSION])dnl -AC_REQUIRE([LTSUGAR_VERSION])dnl -AC_REQUIRE([LTVERSION_VERSION])dnl -AC_REQUIRE([LTOBSOLETE_VERSION])dnl -m4_require([_LT_PROG_LTMAIN])dnl - -_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) - -dnl Parse OPTIONS -_LT_SET_OPTIONS([$0], [$1]) - -# This can be used to rebuild libtool when needed -LIBTOOL_DEPS=$ltmain - -# Always use our own libtool. -LIBTOOL='$(SHELL) $(top_builddir)/libtool' -AC_SUBST(LIBTOOL)dnl - -_LT_SETUP - -# Only expand once: -m4_define([LT_INIT]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:100: -1- AU_DEFUN([AC_PROG_LIBTOOL], [m4_if($#, 0, [LT_INIT], [LT_INIT($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:100: -1- AC_DEFUN([AC_PROG_LIBTOOL], [m4_warn([obsolete], [The macro 'AC_PROG_LIBTOOL' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_INIT], [LT_INIT($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:101: -1- AU_DEFUN([AM_PROG_LIBTOOL], [m4_if($#, 0, [LT_INIT], [LT_INIT($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:101: -1- AC_DEFUN([AM_PROG_LIBTOOL], [m4_warn([obsolete], [The macro 'AM_PROG_LIBTOOL' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_INIT], [LT_INIT($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:621: -1- AC_DEFUN([LT_OUTPUT], [: ${CONFIG_LT=./config.lt} -AC_MSG_NOTICE([creating $CONFIG_LT]) -_LT_GENERATED_FILE_INIT(["$CONFIG_LT"], -[# Run this file to recreate a libtool stub with the current configuration.]) - -cat >>"$CONFIG_LT" <<\_LTEOF -lt_cl_silent=false -exec AS_MESSAGE_LOG_FD>>config.log -{ - echo - AS_BOX([Running $as_me.]) -} >&AS_MESSAGE_LOG_FD - -lt_cl_help="\ -'$as_me' creates a local libtool stub from the current configuration, -for use in further configure time tests before the real libtool is -generated. - -Usage: $[0] [[OPTIONS]] - - -h, --help print this help, then exit - -V, --version print version number, then exit - -q, --quiet do not print progress messages - -d, --debug don't remove temporary files - -Report bugs to ." - -lt_cl_version="\ -m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl -m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) -configured by $[0], generated by m4_PACKAGE_STRING. - -Copyright (C) 2024 Free Software Foundation, Inc. -This config.lt script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it." - -while test 0 != $[#] -do - case $[1] in - --version | --v* | -V ) - echo "$lt_cl_version"; exit 0 ;; - --help | --h* | -h ) - echo "$lt_cl_help"; exit 0 ;; - --debug | --d* | -d ) - debug=: ;; - --quiet | --q* | --silent | --s* | -q ) - lt_cl_silent=: ;; - - -*) AC_MSG_ERROR([unrecognized option: $[1] -Try '$[0] --help' for more information.]) ;; - - *) AC_MSG_ERROR([unrecognized argument: $[1] -Try '$[0] --help' for more information.]) ;; - esac - shift -done - -if $lt_cl_silent; then - exec AS_MESSAGE_FD>/dev/null -fi -_LTEOF - -cat >>"$CONFIG_LT" <<_LTEOF -_LT_OUTPUT_LIBTOOL_COMMANDS_INIT -_LTEOF - -cat >>"$CONFIG_LT" <<\_LTEOF -AC_MSG_NOTICE([creating $ofile]) -_LT_OUTPUT_LIBTOOL_COMMANDS -AS_EXIT(0) -_LTEOF -chmod +x "$CONFIG_LT" - -# configure is writing to config.log, but config.lt does its own redirection, -# appending to config.log, which fails on DOS, as config.log is still kept -# open by configure. Here we exec the FD to /dev/null, effectively closing -# config.log, so it can be properly (re)opened and appended to by config.lt. -lt_cl_success=: -test yes = "$silent" && - lt_config_lt_args="$lt_config_lt_args --quiet" -exec AS_MESSAGE_LOG_FD>/dev/null -$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false -exec AS_MESSAGE_LOG_FD>>config.log -$lt_cl_success || AS_EXIT(1) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:813: -1- AC_DEFUN([LT_SUPPORTED_TAG], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:824: -1- AC_DEFUN([LT_LANG], [AC_BEFORE([$0], [LT_OUTPUT])dnl -m4_case([$1], - [C], [_LT_LANG(C)], - [C++], [_LT_LANG(CXX)], - [Go], [_LT_LANG(GO)], - [Java], [_LT_LANG(GCJ)], - [Fortran 77], [_LT_LANG(F77)], - [Fortran], [_LT_LANG(FC)], - [Windows Resource], [_LT_LANG(RC)], - [m4_ifdef([_LT_LANG_]$1[_CONFIG], - [_LT_LANG($1)], - [m4_fatal([$0: unsupported language: "$1"])])])dnl -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:916: -1- AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:916: -1- AC_DEFUN([AC_LIBTOOL_CXX], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_CXX' is obsolete. -You should run autoupdate.])dnl -LT_LANG(C++)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:917: -1- AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:917: -1- AC_DEFUN([AC_LIBTOOL_F77], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_F77' is obsolete. -You should run autoupdate.])dnl -LT_LANG(Fortran 77)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:918: -1- AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:918: -1- AC_DEFUN([AC_LIBTOOL_FC], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_FC' is obsolete. -You should run autoupdate.])dnl -LT_LANG(Fortran)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:919: -1- AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:919: -1- AC_DEFUN([AC_LIBTOOL_GCJ], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_GCJ' is obsolete. -You should run autoupdate.])dnl -LT_LANG(Java)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:920: -1- AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:920: -1- AC_DEFUN([AC_LIBTOOL_RC], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_RC' is obsolete. -You should run autoupdate.])dnl -LT_LANG(Windows Resource)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1278: -1- AC_DEFUN([_LT_WITH_SYSROOT], [m4_require([_LT_DECL_SED])dnl -AC_MSG_CHECKING([for sysroot]) -AC_ARG_WITH([sysroot], -[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@], - [Search for dependent libraries within DIR (or the compiler's sysroot - if not specified).])], -[], [with_sysroot=no]) - -dnl lt_sysroot will always be passed unquoted. We quote it here -dnl in case the user passed a directory name. -lt_sysroot= -case $with_sysroot in #( - yes) - if test yes = "$GCC"; then - # Trim trailing / since we'll always append absolute paths and we want - # to avoid //, if only for less confusing output for the user. - lt_sysroot=`$CC --print-sysroot 2>/dev/null | $SED 's:/\+$::'` - fi - ;; #( - /*) - lt_sysroot=`echo "$with_sysroot" | $SED -e "$sed_quote_subst"` - ;; #( - no|'') - ;; #( - *) - AC_MSG_RESULT([$with_sysroot]) - AC_MSG_ERROR([The sysroot must be an absolute path.]) - ;; -esac - - AC_MSG_RESULT([${lt_sysroot:-no}]) -_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl -[dependent libraries, and where our libraries should be installed.])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1618: -1- AC_DEFUN([_LT_COMPILER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl -m4_require([_LT_DECL_SED])dnl -AC_CACHE_CHECK([$1], [$2], - [$2=no - m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) - echo "$lt_simple_compile_test_code" > conftest.$ac_ext - lt_compiler_flag="$3" ## exclude from sc_useless_quotes_in_assignment - # Insert the option either (1) after the last *FLAGS variable, or - # (2) before a word containing "conftest.", or (3) at the end. - # Note that $ac_compile itself does not contain backslashes and begins - # with a dollar sign (not a hyphen), so the echo should work correctly. - # The option is referenced via a variable to avoid confusing sed. - lt_compile=`echo "$ac_compile" | $SED \ - -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ - -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ - -e 's:$: $lt_compiler_flag:'` - (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) - (eval "$lt_compile" 2>conftest.err) - ac_status=$? - cat conftest.err >&AS_MESSAGE_LOG_FD - echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD - if (exit $ac_status) && test -s "$ac_outfile"; then - # The compiler can only warn and ignore the option if not recognized - # So say no if there are warnings other than the usual output. - $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp - $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 - if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then - $2=yes - fi - fi - $RM conftest* -]) - -if test yes = "[$]$2"; then - m4_if([$5], , :, [$5]) -else - m4_if([$6], , :, [$6]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1660: -1- AU_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [m4_if($#, 0, [_LT_COMPILER_OPTION], [_LT_COMPILER_OPTION($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1660: -1- AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_COMPILER_OPTION' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [_LT_COMPILER_OPTION], [_LT_COMPILER_OPTION($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1669: -1- AC_DEFUN([_LT_LINKER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl -m4_require([_LT_DECL_SED])dnl -AC_CACHE_CHECK([$1], [$2], - [$2=no - save_LDFLAGS=$LDFLAGS - LDFLAGS="$LDFLAGS $3" - echo "$lt_simple_link_test_code" > conftest.$ac_ext - if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then - # The linker can only warn and ignore the option if not recognized - # So say no if there are warnings - if test -s conftest.err; then - # Append any errors to the config.log. - cat conftest.err 1>&AS_MESSAGE_LOG_FD - $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp - $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 - if diff conftest.exp conftest.er2 >/dev/null; then - $2=yes - fi - else - $2=yes - fi - fi - $RM -r conftest* - LDFLAGS=$save_LDFLAGS -]) - -if test yes = "[$]$2"; then - m4_if([$4], , :, [$4]) -else - m4_if([$5], , :, [$5]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1704: -1- AU_DEFUN([AC_LIBTOOL_LINKER_OPTION], [m4_if($#, 0, [_LT_LINKER_OPTION], [_LT_LINKER_OPTION($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1704: -1- AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_LINKER_OPTION' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [_LT_LINKER_OPTION], [_LT_LINKER_OPTION($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1711: -1- AC_DEFUN([LT_CMD_MAX_LEN], [AC_REQUIRE([AC_CANONICAL_HOST])dnl -# find the maximum length of command line arguments -AC_MSG_CHECKING([the maximum length of command line arguments]) -AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl - i=0 - teststring=ABCD - - case $build_os in - msdosdjgpp*) - # On DJGPP, this test can blow up pretty badly due to problems in libc - # (any single argument exceeding 2000 bytes causes a buffer overrun - # during glob expansion). Even if it were fixed, the result of this - # check would be larger than it should be. - lt_cv_sys_max_cmd_len=12288; # 12K is about right - ;; - - gnu* | ironclad* | redox*) - # Under GNU Hurd, Ironclad and Redox, this test is not required - # because there is no limit to the length of command line arguments. - # Libtool will interpret -1 as no limit whatsoever - lt_cv_sys_max_cmd_len=-1; - ;; - - cygwin* | mingw* | windows* | cegcc*) - # On Win9x/ME, this test blows up -- it succeeds, but takes - # about 5 minutes as the teststring grows exponentially. - # Worse, since 9x/ME are not pre-emptively multitasking, - # you end up with a "frozen" computer, even though with patience - # the test eventually succeeds (with a max line length of 256k). - # Instead, let's just punt: use the minimum linelength reported by - # all of the supported platforms: 8192 (on NT/2K/XP). - lt_cv_sys_max_cmd_len=8192; - ;; - - mint*) - # On MiNT this can take a long time and run out of memory. - lt_cv_sys_max_cmd_len=8192; - ;; - - amigaos*) - # On AmigaOS with pdksh, this test takes hours, literally. - # So we just punt and use a minimum line length of 8192. - lt_cv_sys_max_cmd_len=8192; - ;; - - darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*) - # This has been around since 386BSD, at least. Likely further. - if test -x /sbin/sysctl; then - lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` - elif test -x /usr/sbin/sysctl; then - lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` - else - lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs - fi - # And add a safety zone - lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` - lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` - ;; - - interix*) - # We know the value 262144 and hardcode it with a safety zone (like BSD) - lt_cv_sys_max_cmd_len=196608 - ;; - - os2*) - # The test takes a long time on OS/2. - lt_cv_sys_max_cmd_len=8192 - ;; - - osf*) - # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure - # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not - # nice to cause kernel panics so lets avoid the loop below. - # First set a reasonable default. - lt_cv_sys_max_cmd_len=16384 - # - if test -x /sbin/sysconfig; then - case `/sbin/sysconfig -q proc exec_disable_arg_limit` in - *1*) lt_cv_sys_max_cmd_len=-1 ;; - esac - fi - ;; - sco3.2v5*) - lt_cv_sys_max_cmd_len=102400 - ;; - sysv5* | sco5v6* | sysv4.2uw2*) - kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` - if test -n "$kargmax"; then - lt_cv_sys_max_cmd_len=`echo $kargmax | $SED 's/.*[[ ]]//'` - else - lt_cv_sys_max_cmd_len=32768 - fi - ;; - *) - lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` - if test -n "$lt_cv_sys_max_cmd_len" && \ - test undefined != "$lt_cv_sys_max_cmd_len"; then - lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` - lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` - else - # Make teststring a little bigger before we do anything with it. - # a 1K string should be a reasonable start. - for i in 1 2 3 4 5 6 7 8; do - teststring=$teststring$teststring - done - SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} - # If test is not a shell built-in, we'll probably end up computing a - # maximum length that is only half of the actual maximum length, but - # we can't tell. - while { test X`env echo "$teststring$teststring" 2>/dev/null` \ - = "X$teststring$teststring"; } >/dev/null 2>&1 && - test 17 != "$i" # 1/2 MB should be enough - do - i=`expr $i + 1` - teststring=$teststring$teststring - done - # Only check the string length outside the loop. - lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` - teststring= - # Add a significant safety factor because C++ compilers can tack on - # massive amounts of additional arguments before passing them to the - # linker. It appears as though 1/2 is a usable value. - lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` - fi - ;; - esac -]) -if test -n "$lt_cv_sys_max_cmd_len"; then - AC_MSG_RESULT($lt_cv_sys_max_cmd_len) -else - AC_MSG_RESULT(none) -fi -max_cmd_len=$lt_cv_sys_max_cmd_len -_LT_DECL([], [max_cmd_len], [0], - [What is the maximum length of a command?]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1850: -1- AU_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [m4_if($#, 0, [LT_CMD_MAX_LEN], [LT_CMD_MAX_LEN($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1850: -1- AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_SYS_MAX_CMD_LEN' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_CMD_MAX_LEN], [LT_CMD_MAX_LEN($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:1961: -1- AC_DEFUN([LT_SYS_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl -if test yes != "$enable_dlopen"; then - enable_dlopen=unknown - enable_dlopen_self=unknown - enable_dlopen_self_static=unknown -else - lt_cv_dlopen=no - lt_cv_dlopen_libs= - - case $host_os in - beos*) - lt_cv_dlopen=load_add_on - lt_cv_dlopen_libs= - lt_cv_dlopen_self=yes - ;; - - mingw* | windows* | pw32* | cegcc*) - lt_cv_dlopen=LoadLibrary - lt_cv_dlopen_libs= - ;; - - cygwin*) - lt_cv_dlopen=dlopen - lt_cv_dlopen_libs= - ;; - - darwin*) - # if libdl is installed we need to link against it - AC_CHECK_LIB([dl], [dlopen], - [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[ - lt_cv_dlopen=dyld - lt_cv_dlopen_libs= - lt_cv_dlopen_self=yes - ]) - ;; - - tpf*) - # Don't try to run any link tests for TPF. We know it's impossible - # because TPF is a cross-compiler, and we know how we open DSOs. - lt_cv_dlopen=dlopen - lt_cv_dlopen_libs= - lt_cv_dlopen_self=no - ;; - - *) - AC_CHECK_FUNC([shl_load], - [lt_cv_dlopen=shl_load], - [AC_CHECK_LIB([dld], [shl_load], - [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld], - [AC_CHECK_FUNC([dlopen], - [lt_cv_dlopen=dlopen], - [AC_CHECK_LIB([dl], [dlopen], - [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl], - [AC_CHECK_LIB([svld], [dlopen], - [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld], - [AC_CHECK_LIB([dld], [dld_link], - [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld]) - ]) - ]) - ]) - ]) - ]) - ;; - esac - - if test no = "$lt_cv_dlopen"; then - enable_dlopen=no - else - enable_dlopen=yes - fi - - case $lt_cv_dlopen in - dlopen) - save_CPPFLAGS=$CPPFLAGS - test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" - - save_LDFLAGS=$LDFLAGS - wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" - - save_LIBS=$LIBS - LIBS="$lt_cv_dlopen_libs $LIBS" - - AC_CACHE_CHECK([whether a program can dlopen itself], - lt_cv_dlopen_self, [dnl - _LT_TRY_DLOPEN_SELF( - lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, - lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) - ]) - - if test yes = "$lt_cv_dlopen_self"; then - wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" - AC_CACHE_CHECK([whether a statically linked program can dlopen itself], - lt_cv_dlopen_self_static, [dnl - _LT_TRY_DLOPEN_SELF( - lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, - lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) - ]) - fi - - CPPFLAGS=$save_CPPFLAGS - LDFLAGS=$save_LDFLAGS - LIBS=$save_LIBS - ;; - esac - - case $lt_cv_dlopen_self in - yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; - *) enable_dlopen_self=unknown ;; - esac - - case $lt_cv_dlopen_self_static in - yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; - *) enable_dlopen_self_static=unknown ;; - esac -fi -_LT_DECL([dlopen_support], [enable_dlopen], [0], - [Whether dlopen is supported]) -_LT_DECL([dlopen_self], [enable_dlopen_self], [0], - [Whether dlopen of programs is supported]) -_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], - [Whether dlopen of statically linked programs is supported]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:2086: -1- AU_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [m4_if($#, 0, [LT_SYS_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:2086: -1- AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_DLOPEN_SELF' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3296: -1- AC_DEFUN([_LT_PATH_TOOL_PREFIX], [m4_require([_LT_DECL_EGREP])dnl -AC_MSG_CHECKING([for $1]) -AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, -[case $MAGIC_CMD in -[[\\/*] | ?:[\\/]*]) - lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. - ;; -*) - lt_save_MAGIC_CMD=$MAGIC_CMD - lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR -dnl $ac_dummy forces splitting on constant user-supplied paths. -dnl POSIX.2 word splitting is done only on the output of word expansions, -dnl not every word. This closes a longstanding sh security hole. - ac_dummy="m4_if([$2], , $PATH, [$2])" - for ac_dir in $ac_dummy; do - IFS=$lt_save_ifs - test -z "$ac_dir" && ac_dir=. - if test -f "$ac_dir/$1"; then - lt_cv_path_MAGIC_CMD=$ac_dir/"$1" - if test -n "$file_magic_test_file"; then - case $deplibs_check_method in - "file_magic "*) - file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` - MAGIC_CMD=$lt_cv_path_MAGIC_CMD - if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | - $EGREP "$file_magic_regex" > /dev/null; then - : - else - cat <<_LT_EOF 1>&2 - -*** Warning: the command libtool uses to detect shared libraries, -*** $file_magic_cmd, produces output that libtool cannot recognize. -*** The result is that libtool may fail to recognize shared libraries -*** as such. This will affect the creation of libtool libraries that -*** depend on shared libraries, but programs linked with such libtool -*** libraries will work regardless of this problem. Nevertheless, you -*** may want to report the problem to your system manager and/or to -*** bug-libtool@gnu.org - -_LT_EOF - fi ;; - esac - fi - break - fi - done - IFS=$lt_save_ifs - MAGIC_CMD=$lt_save_MAGIC_CMD - ;; -esac]) -MAGIC_CMD=$lt_cv_path_MAGIC_CMD -if test -n "$MAGIC_CMD"; then - AC_MSG_RESULT($MAGIC_CMD) -else - AC_MSG_RESULT(no) -fi -_LT_DECL([], [MAGIC_CMD], [0], - [Used to examine libraries when file_magic_cmd begins with "file"])dnl -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3358: -1- AU_DEFUN([AC_PATH_TOOL_PREFIX], [m4_if($#, 0, [_LT_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3358: -1- AC_DEFUN([AC_PATH_TOOL_PREFIX], [m4_warn([obsolete], [The macro 'AC_PATH_TOOL_PREFIX' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [_LT_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3381: -1- AC_DEFUN([LT_PATH_LD], [AC_REQUIRE([AC_PROG_CC])dnl -AC_REQUIRE([AC_CANONICAL_HOST])dnl -AC_REQUIRE([AC_CANONICAL_BUILD])dnl -m4_require([_LT_DECL_SED])dnl -m4_require([_LT_DECL_EGREP])dnl -m4_require([_LT_PROG_ECHO_BACKSLASH])dnl - -AC_ARG_WITH([gnu-ld], - [AS_HELP_STRING([--with-gnu-ld], - [assume the C compiler uses GNU ld @<:@default=no@:>@])], - [test no = "$withval" || with_gnu_ld=yes], - [with_gnu_ld=no])dnl - -ac_prog=ld -if test yes = "$GCC"; then - # Check if gcc -print-prog-name=ld gives a path. - AC_MSG_CHECKING([for ld used by $CC]) - case $host in - *-*-mingw* | *-*-windows*) - # gcc leaves a trailing carriage return, which upsets mingw - ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; - *) - ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; - esac - case $ac_prog in - # Accept absolute paths. - [[\\/]]* | ?:[[\\/]]*) - re_direlt='/[[^/]][[^/]]*/\.\./' - # Canonicalize the pathname of ld - ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` - while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do - ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` - done - test -z "$LD" && LD=$ac_prog - ;; - "") - # If it fails, then pretend we aren't using GCC. - ac_prog=ld - ;; - *) - # If it is relative, then search for the first ld in PATH. - with_gnu_ld=unknown - ;; - esac -elif test yes = "$with_gnu_ld"; then - AC_MSG_CHECKING([for GNU ld]) -else - AC_MSG_CHECKING([for non-GNU ld]) -fi -AC_CACHE_VAL(lt_cv_path_LD, -[if test -z "$LD"; then - lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR - for ac_dir in $PATH; do - IFS=$lt_save_ifs - test -z "$ac_dir" && ac_dir=. - if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then - lt_cv_path_LD=$ac_dir/$ac_prog - # Check to see if the program is GNU ld. I'd rather use --version, - # but apparently some variants of GNU ld only accept -v. - # Break only if it was the GNU/non-GNU ld that we prefer. - case `"$lt_cv_path_LD" -v 2>&1 &1 | $SED '1q'` in - *$lt_bad_file* | *'Invalid file or object type'*) - lt_cv_path_NM="$tmp_nm -B" - break 2 - ;; - *) - case `"$tmp_nm" -p /dev/null 2>&1 | $SED '1q'` in - */dev/null*) - lt_cv_path_NM="$tmp_nm -p" - break 2 - ;; - *) - lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but - continue # so that we can try to find one that supports BSD flags - ;; - esac - ;; - esac - fi - done - IFS=$lt_save_ifs - done - : ${lt_cv_path_NM=no} -fi]) -if test no != "$lt_cv_path_NM"; then - NM=$lt_cv_path_NM -else - # Didn't find any BSD compatible name lister, look for dumpbin. - if test -n "$DUMPBIN"; then : - # Let the user override the test. - else - AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) - case `$DUMPBIN -symbols -headers /dev/null 2>&1 | $SED '1q'` in - *COFF*) - DUMPBIN="$DUMPBIN -symbols -headers" - ;; - *) - DUMPBIN=: - ;; - esac - fi - AC_SUBST([DUMPBIN]) - if test : != "$DUMPBIN"; then - NM=$DUMPBIN - fi -fi -test -z "$NM" && NM=nm -AC_SUBST([NM]) -_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl - -AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], - [lt_cv_nm_interface="BSD nm" - echo "int some_variable = 0;" > conftest.$ac_ext - (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) - (eval "$ac_compile" 2>conftest.err) - cat conftest.err >&AS_MESSAGE_LOG_FD - (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) - (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) - cat conftest.err >&AS_MESSAGE_LOG_FD - (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) - cat conftest.out >&AS_MESSAGE_LOG_FD - if $GREP 'External.*some_variable' conftest.out > /dev/null; then - lt_cv_nm_interface="MS dumpbin" - fi - rm -f conftest*]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3906: -1- AU_DEFUN([AM_PROG_NM], [m4_if($#, 0, [LT_PATH_NM], [LT_PATH_NM($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3906: -1- AC_DEFUN([AM_PROG_NM], [m4_warn([obsolete], [The macro 'AM_PROG_NM' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_PATH_NM], [LT_PATH_NM($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3907: -1- AU_DEFUN([AC_PROG_NM], [m4_if($#, 0, [LT_PATH_NM], [LT_PATH_NM($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3907: -1- AC_DEFUN([AC_PROG_NM], [m4_warn([obsolete], [The macro 'AC_PROG_NM' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_PATH_NM], [LT_PATH_NM($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3978: -1- AC_DEFUN([_LT_DLL_DEF_P], [dnl - test DEF = "`$SED -n dnl - -e '\''s/^[[ ]]*//'\'' dnl Strip leading whitespace - -e '\''/^\(;.*\)*$/d'\'' dnl Delete empty lines and comments - -e '\''s/^\(EXPORTS\|LIBRARY\)\([[ ]].*\)*$/DEF/p'\'' dnl - -e q dnl Only consider the first "real" line - $1`" dnl -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:3992: -1- AC_DEFUN([LT_LIB_M], [AC_REQUIRE([AC_CANONICAL_HOST])dnl -LIBM= -case $host in -*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-mingw* | *-*-pw32* | *-*-darwin*) - # These system don't have libm, or don't need it - ;; -*-ncr-sysv4.3*) - AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw) - AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") - ;; -*) - AC_CHECK_LIB(m, cos, LIBM=-lm) - ;; -esac -AC_SUBST([LIBM]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:4011: -1- AU_DEFUN([AC_CHECK_LIBM], [m4_if($#, 0, [LT_LIB_M], [LT_LIB_M($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:4011: -1- AC_DEFUN([AC_CHECK_LIBM], [m4_warn([obsolete], [The macro 'AC_CHECK_LIBM' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_LIB_M], [LT_LIB_M($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8336: -1- AC_DEFUN([LT_PROG_GCJ], [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], - [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], - [AC_CHECK_TOOL(GCJ, gcj,) - test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2" - AC_SUBST(GCJFLAGS)])])[]dnl -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8345: -1- AU_DEFUN([LT_AC_PROG_GCJ], [m4_if($#, 0, [LT_PROG_GCJ], [LT_PROG_GCJ($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8345: -1- AC_DEFUN([LT_AC_PROG_GCJ], [m4_warn([obsolete], [The macro 'LT_AC_PROG_GCJ' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_PROG_GCJ], [LT_PROG_GCJ($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8352: -1- AC_DEFUN([LT_PROG_GO], [AC_CHECK_TOOL(GOC, gccgo,) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8359: -1- AC_DEFUN([LT_PROG_RC], [AC_CHECK_TOOL(RC, windres,) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8364: -1- AU_DEFUN([LT_AC_PROG_RC], [m4_if($#, 0, [LT_PROG_RC], [LT_PROG_RC($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/libtool.m4:8364: -1- AC_DEFUN([LT_AC_PROG_RC], [m4_warn([obsolete], [The macro 'LT_AC_PROG_RC' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_PROG_RC], [LT_PROG_RC($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltargz.m4:13: -1- AC_DEFUN([LT_FUNC_ARGZ], [ -dnl Required for use of '$SED' in Cygwin configuration. -AC_REQUIRE([AC_PROG_SED])dnl -AC_CHECK_HEADERS([argz.h], [], [], [AC_INCLUDES_DEFAULT]) - -AC_CHECK_TYPES([error_t], - [], - [AC_DEFINE([error_t], [int], - [Define to a type to use for 'error_t' if it is not otherwise available.]) - AC_DEFINE([__error_t_defined], [1], [Define so that glibc/gnulib argp.h - does not typedef error_t.])], - [#if defined(HAVE_ARGZ_H) -# include -#endif]) - -LT_ARGZ_H= -AC_CHECK_FUNCS([argz_add argz_append argz_count argz_create_sep argz_insert \ - argz_next argz_stringify], [], [LT_ARGZ_H=lt__argz.h; AC_LIBOBJ([lt__argz])]) - -dnl if have system argz functions, allow forced use of -dnl libltdl-supplied implementation (and default to do so -dnl on "known bad" systems). Could use a runtime check, but -dnl (a) detecting malloc issues is notoriously unreliable -dnl (b) only known system that declares argz functions, -dnl provides them, yet they are broken, is cygwin -dnl releases prior to 16-Mar-2007 (1.5.24 and earlier) -dnl So, it's more straightforward simply to special case -dnl this for known bad systems. -AS_IF([test -z "$LT_ARGZ_H"], - [AC_CACHE_CHECK( - [if argz actually works], - [lt_cv_sys_argz_works], - [[case $host_os in #( - *cygwin*) - lt_cv_sys_argz_works=no - if test no != "$cross_compiling"; then - lt_cv_sys_argz_works="guessing no" - else - lt_sed_extract_leading_digits='s/^\([0-9\.]*\).*/\1/' - save_IFS=$IFS - IFS=-. - set x `uname -r | $SED -e "$lt_sed_extract_leading_digits"` - IFS=$save_IFS - lt_os_major=${2-0} - lt_os_minor=${3-0} - lt_os_micro=${4-0} - if test 1 -lt "$lt_os_major" \ - || { test 1 -eq "$lt_os_major" \ - && { test 5 -lt "$lt_os_minor" \ - || { test 5 -eq "$lt_os_minor" \ - && test 24 -lt "$lt_os_micro"; }; }; }; then - lt_cv_sys_argz_works=yes - fi - fi - ;; #( - *) lt_cv_sys_argz_works=yes ;; - esac]]) - AS_IF([test yes = "$lt_cv_sys_argz_works"], - [AC_DEFINE([HAVE_WORKING_ARGZ], 1, - [This value is set to 1 to indicate that the system argz facility works])], - [LT_ARGZ_H=lt__argz.h - AC_LIBOBJ([lt__argz])])]) - -AC_SUBST([LT_ARGZ_H]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:17: -1- AC_DEFUN([LT_CONFIG_LTDL_DIR], [AC_BEFORE([$0], [LTDL_INIT]) -_$0($*) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:69: -1- AC_DEFUN([LTDL_CONVENIENCE], [AC_BEFORE([$0], [LTDL_INIT])dnl -dnl Although the argument is deprecated and no longer documented, -dnl LTDL_CONVENIENCE used to take a DIRECTORY orgument, if we have one -dnl here make sure it is the same as any other declaration of libltdl's -dnl location! This also ensures lt_ltdl_dir is set when configure.ac is -dnl not yet using an explicit LT_CONFIG_LTDL_DIR. -m4_ifval([$1], [_LT_CONFIG_LTDL_DIR([$1])])dnl -_$0() -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:82: -1- AU_DEFUN([AC_LIBLTDL_CONVENIENCE], [_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])]) -_LTDL_CONVENIENCE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:82: -1- AC_DEFUN([AC_LIBLTDL_CONVENIENCE], [m4_warn([obsolete], [The macro 'AC_LIBLTDL_CONVENIENCE' is obsolete. -You should run autoupdate.])dnl -_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])]) -_LTDL_CONVENIENCE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:125: -1- AC_DEFUN([LTDL_INSTALLABLE], [AC_BEFORE([$0], [LTDL_INIT])dnl -dnl Although the argument is deprecated and no longer documented, -dnl LTDL_INSTALLABLE used to take a DIRECTORY orgument, if we have one -dnl here make sure it is the same as any other declaration of libltdl's -dnl location! This also ensures lt_ltdl_dir is set when configure.ac is -dnl not yet using an explicit LT_CONFIG_LTDL_DIR. -m4_ifval([$1], [_LT_CONFIG_LTDL_DIR([$1])])dnl -_$0() -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:138: -1- AU_DEFUN([AC_LIBLTDL_INSTALLABLE], [_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])]) -_LTDL_INSTALLABLE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:138: -1- AC_DEFUN([AC_LIBLTDL_INSTALLABLE], [m4_warn([obsolete], [The macro 'AC_LIBLTDL_INSTALLABLE' is obsolete. -You should run autoupdate.])dnl -_LT_CONFIG_LTDL_DIR([m4_default([$1], [libltdl])]) -_LTDL_INSTALLABLE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:214: -1- AC_DEFUN([_LT_LIBOBJ], [ - m4_pattern_allow([^_LT_LIBOBJS$]) - _LT_LIBOBJS="$_LT_LIBOBJS $1.$ac_objext" -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:227: -1- AC_DEFUN([LTDL_INIT], [dnl Parse OPTIONS -_LT_SET_OPTIONS([$0], [$1]) - -dnl We need to keep our own list of libobjs separate from our parent project, -dnl and the easiest way to do that is redefine the AC_LIBOBJs macro while -dnl we look for our own LIBOBJs. -m4_pushdef([AC_LIBOBJ], m4_defn([_LT_LIBOBJ])) -m4_pushdef([AC_LIBSOURCES]) - -dnl If not otherwise defined, default to the 1.5.x compatible subproject mode: -m4_if(_LTDL_MODE, [], - [m4_define([_LTDL_MODE], m4_default([$2], [subproject])) - m4_if([-1], [m4_bregexp(_LTDL_MODE, [\(subproject\|\(non\)?recursive\)])], - [m4_fatal([unknown libltdl mode: ]_LTDL_MODE)])]) - -AC_ARG_WITH([included_ltdl], - [AS_HELP_STRING([--with-included-ltdl], - [use the GNU ltdl sources included here])]) - -if test yes != "$with_included_ltdl"; then - # We are not being forced to use the included libltdl sources, so - # decide whether there is a useful installed version we can use. - AC_CHECK_HEADER([ltdl.h], - [AC_CHECK_DECL([lt_dlinterface_register], - [AC_CHECK_LIB([ltdl], [lt_dladvise_preload], - [with_included_ltdl=no], - [with_included_ltdl=yes])], - [with_included_ltdl=yes], - [AC_INCLUDES_DEFAULT - #include ])], - [with_included_ltdl=yes], - [AC_INCLUDES_DEFAULT] - ) -fi - -dnl If neither LT_CONFIG_LTDL_DIR, LTDL_CONVENIENCE nor LTDL_INSTALLABLE -dnl was called yet, then for old times' sake, we assume libltdl is in an -dnl eponymous directory: -AC_PROVIDE_IFELSE([LT_CONFIG_LTDL_DIR], [], [_LT_CONFIG_LTDL_DIR([libltdl])]) - -AC_ARG_WITH([ltdl_include], - [AS_HELP_STRING([--with-ltdl-include=DIR], - [use the ltdl headers installed in DIR])]) - -if test -n "$with_ltdl_include"; then - if test -f "$with_ltdl_include/ltdl.h"; then : - else - AC_MSG_ERROR([invalid ltdl include directory: '$with_ltdl_include']) - fi -else - with_ltdl_include=no -fi - -AC_ARG_WITH([ltdl_lib], - [AS_HELP_STRING([--with-ltdl-lib=DIR], - [use the libltdl.la installed in DIR])]) - -if test -n "$with_ltdl_lib"; then - if test -f "$with_ltdl_lib/libltdl.la"; then : - else - AC_MSG_ERROR([invalid ltdl library directory: '$with_ltdl_lib']) - fi -else - with_ltdl_lib=no -fi - -case ,$with_included_ltdl,$with_ltdl_include,$with_ltdl_lib, in - ,yes,no,no,) - m4_case(m4_default(_LTDL_TYPE, [convenience]), - [convenience], [_LTDL_CONVENIENCE], - [installable], [_LTDL_INSTALLABLE], - [m4_fatal([unknown libltdl build type: ]_LTDL_TYPE)]) - ;; - ,no,no,no,) - # If the included ltdl is not to be used, then use the - # preinstalled libltdl we found. - AC_DEFINE([HAVE_LTDL], [1], - [Define this if a modern libltdl is already installed]) - LIBLTDL=-lltdl - LTDLDEPS= - LTDLINCL= - ;; - ,no*,no,*) - AC_MSG_ERROR(['--with-ltdl-include' and '--with-ltdl-lib' options must be used together]) - ;; - *) with_included_ltdl=no - LIBLTDL="-L$with_ltdl_lib -lltdl" - LTDLDEPS= - LTDLINCL=-I$with_ltdl_include - ;; -esac -INCLTDL=$LTDLINCL - -# Report our decision... -AC_MSG_CHECKING([where to find libltdl headers]) -AC_MSG_RESULT([$LTDLINCL]) -AC_MSG_CHECKING([where to find libltdl library]) -AC_MSG_RESULT([$LIBLTDL]) - -_LTDL_SETUP - -dnl restore autoconf definition. -m4_popdef([AC_LIBOBJ]) -m4_popdef([AC_LIBSOURCES]) - -AC_CONFIG_COMMANDS_PRE([ - _ltdl_libobjs= - _ltdl_ltlibobjs= - if test -n "$_LT_LIBOBJS"; then - # Remove the extension. - _lt_sed_drop_objext='s/\.o$//;s/\.obj$//' - for i in `for i in $_LT_LIBOBJS; do echo "$i"; done | $SED "$_lt_sed_drop_objext" | sort -u`; do - _ltdl_libobjs="$_ltdl_libobjs $lt_libobj_prefix$i.$ac_objext" - _ltdl_ltlibobjs="$_ltdl_ltlibobjs $lt_libobj_prefix$i.lo" - done - fi - AC_SUBST([ltdl_LIBOBJS], [$_ltdl_libobjs]) - AC_SUBST([ltdl_LTLIBOBJS], [$_ltdl_ltlibobjs]) -]) - -# Only expand once: -m4_define([LTDL_INIT]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:353: -1- AU_DEFUN([AC_LIB_LTDL], [LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:353: -1- AC_DEFUN([AC_LIB_LTDL], [m4_warn([obsolete], [The macro 'AC_LIB_LTDL' is obsolete. -You should run autoupdate.])dnl -LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:354: -1- AU_DEFUN([AC_WITH_LTDL], [LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:354: -1- AC_DEFUN([AC_WITH_LTDL], [m4_warn([obsolete], [The macro 'AC_WITH_LTDL' is obsolete. -You should run autoupdate.])dnl -LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:355: -1- AU_DEFUN([LT_WITH_LTDL], [LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:355: -1- AC_DEFUN([LT_WITH_LTDL], [m4_warn([obsolete], [The macro 'LT_WITH_LTDL' is obsolete. -You should run autoupdate.])dnl -LTDL_INIT($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:368: -1- AC_DEFUN([_LTDL_SETUP], [AC_REQUIRE([AC_PROG_CC])dnl -AC_REQUIRE([LT_SYS_MODULE_EXT])dnl -AC_REQUIRE([LT_SYS_MODULE_PATH])dnl -AC_REQUIRE([LT_SYS_DLSEARCH_PATH])dnl -AC_REQUIRE([LT_LIB_DLLOAD])dnl -AC_REQUIRE([LT_SYS_SYMBOL_USCORE])dnl -AC_REQUIRE([LT_FUNC_DLSYM_USCORE])dnl -AC_REQUIRE([LT_SYS_DLOPEN_DEPLIBS])dnl -AC_REQUIRE([LT_FUNC_ARGZ])dnl - -m4_require([_LT_CHECK_OBJDIR])dnl -m4_require([_LT_HEADER_DLFCN])dnl -m4_require([_LT_CHECK_DLPREOPEN])dnl -m4_require([_LT_DECL_SED])dnl - -dnl Don't require this, or it will be expanded earlier than the code -dnl that sets the variables it relies on: -_LT_ENABLE_INSTALL - -dnl _LTDL_MODE specific code must be called at least once: -_LTDL_MODE_DISPATCH - -# In order that ltdl.c can compile, find out the first AC_CONFIG_HEADERS -# the user used. This is so that ltdl.h can pick up the parent projects -# config.h file, The first file in AC_CONFIG_HEADERS must contain the -# definitions required by ltdl.c. -# FIXME: Remove use of undocumented AC_LIST_HEADERS (2.59 compatibility). -AC_CONFIG_COMMANDS_PRE([dnl -m4_pattern_allow([^LT_CONFIG_H$])dnl -m4_ifset([AH_HEADER], - [LT_CONFIG_H=AH_HEADER], - [m4_ifset([AC_LIST_HEADERS], - [LT_CONFIG_H=`echo "AC_LIST_HEADERS" | $SED 's|^[[ ]]*||;s|[[ :]].*$||'`], - [])])]) -AC_SUBST([LT_CONFIG_H]) - -AC_CHECK_HEADERS([unistd.h dl.h sys/dl.h dld.h mach-o/dyld.h dirent.h], - [], [], [AC_INCLUDES_DEFAULT]) - -AC_CHECK_FUNCS([closedir opendir readdir], [], [AC_LIBOBJ([lt__dirent])]) -AC_CHECK_FUNCS([strlcat strlcpy], [], [AC_LIBOBJ([lt__strl])]) - -m4_pattern_allow([LT_LIBEXT])dnl -AC_DEFINE_UNQUOTED([LT_LIBEXT],["$libext"],[The archive extension]) - -name= -eval "lt_libprefix=\"$libname_spec\"" -m4_pattern_allow([LT_LIBPREFIX])dnl -AC_DEFINE_UNQUOTED([LT_LIBPREFIX],["$lt_libprefix"],[The archive prefix]) - -name=ltdl -eval "LTDLOPEN=\"$libname_spec\"" -AC_SUBST([LTDLOPEN]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:445: -1- AC_DEFUN([LT_SYS_DLOPEN_DEPLIBS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl -AC_CACHE_CHECK([whether deplibs are loaded by dlopen], - [lt_cv_sys_dlopen_deplibs], - [# PORTME does your system automatically load deplibs for dlopen? - # or its logical equivalent (e.g. shl_load for HP-UX < 11) - # For now, we just catch OSes we know something about -- in the - # future, we'll try test this programmatically. - lt_cv_sys_dlopen_deplibs=unknown - case $host_os in - aix3*|aix4.1.*|aix4.2.*) - # Unknown whether this is true for these versions of AIX, but - # we want this 'case' here to explicitly catch those versions. - lt_cv_sys_dlopen_deplibs=unknown - ;; - aix[[4-9]]*) - lt_cv_sys_dlopen_deplibs=yes - ;; - amigaos*) - case $host_cpu in - powerpc) - lt_cv_sys_dlopen_deplibs=no - ;; - esac - ;; - darwin*) - # Assuming the user has installed a libdl from somewhere, this is true - # If you are looking for one http://www.opendarwin.org/projects/dlcompat - lt_cv_sys_dlopen_deplibs=yes - ;; - freebsd* | dragonfly* | midnightbsd*) - lt_cv_sys_dlopen_deplibs=yes - ;; - gnu* | linux* | k*bsd*-gnu | kopensolaris*-gnu) - # GNU and its variants, using gnu ld.so (Glibc) - lt_cv_sys_dlopen_deplibs=yes - ;; - hpux10*|hpux11*) - lt_cv_sys_dlopen_deplibs=yes - ;; - interix*) - lt_cv_sys_dlopen_deplibs=yes - ;; - irix[[12345]]*|irix6.[[01]]*) - # Catch all versions of IRIX before 6.2, and indicate that we don't - # know how it worked for any of those versions. - lt_cv_sys_dlopen_deplibs=unknown - ;; - irix*) - # The case above catches anything before 6.2, and it's known that - # at 6.2 and later dlopen does load deplibs. - lt_cv_sys_dlopen_deplibs=yes - ;; - *-mlibc) - lt_cv_sys_dlopen_deplibs=yes - ;; - redox*) - lt_cv_sys_dlopen_deplibs=yes - ;; - netbsd* | netbsdelf*-gnu) - lt_cv_sys_dlopen_deplibs=yes - ;; - openbsd*) - lt_cv_sys_dlopen_deplibs=yes - ;; - osf[[1234]]*) - # dlopen did load deplibs (at least at 4.x), but until the 5.x series, - # it did *not* use an RPATH in a shared library to find objects the - # library depends on, so we explicitly say 'no'. - lt_cv_sys_dlopen_deplibs=no - ;; - osf5.0|osf5.0a|osf5.1) - # dlopen *does* load deplibs and with the right loader patch applied - # it even uses RPATH in a shared library to search for shared objects - # that the library depends on, but there's no easy way to know if that - # patch is installed. Since this is the case, all we can really - # say is unknown -- it depends on the patch being installed. If - # it is, this changes to 'yes'. Without it, it would be 'no'. - lt_cv_sys_dlopen_deplibs=unknown - ;; - osf*) - # the two cases above should catch all versions of osf <= 5.1. Read - # the comments above for what we know about them. - # At > 5.1, deplibs are loaded *and* any RPATH in a shared library - # is used to find them so we can finally say 'yes'. - lt_cv_sys_dlopen_deplibs=yes - ;; - qnx*) - lt_cv_sys_dlopen_deplibs=yes - ;; - solaris*) - lt_cv_sys_dlopen_deplibs=yes - ;; - sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) - libltdl_cv_sys_dlopen_deplibs=yes - ;; - esac - ]) -if test yes != "$lt_cv_sys_dlopen_deplibs"; then - AC_DEFINE([LTDL_DLOPEN_DEPLIBS], [1], - [Define if the OS needs help to load dependent libraries for dlopen().]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:550: -1- AU_DEFUN([AC_LTDL_SYS_DLOPEN_DEPLIBS], [m4_if($#, 0, [LT_SYS_DLOPEN_DEPLIBS], [LT_SYS_DLOPEN_DEPLIBS($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:550: -1- AC_DEFUN([AC_LTDL_SYS_DLOPEN_DEPLIBS], [m4_warn([obsolete], [The macro 'AC_LTDL_SYS_DLOPEN_DEPLIBS' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_DLOPEN_DEPLIBS], [LT_SYS_DLOPEN_DEPLIBS($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:557: -1- AC_DEFUN([LT_SYS_MODULE_EXT], [m4_require([_LT_SYS_DYNAMIC_LINKER])dnl -AC_CACHE_CHECK([what extension is used for runtime loadable modules], - [libltdl_cv_shlibext], -[ -module=yes -eval libltdl_cv_shlibext=$shrext_cmds -module=no -eval libltdl_cv_shrext=$shrext_cmds - ]) -if test -n "$libltdl_cv_shlibext"; then - m4_pattern_allow([LT_MODULE_EXT])dnl - AC_DEFINE_UNQUOTED([LT_MODULE_EXT], ["$libltdl_cv_shlibext"], - [Define to the extension used for runtime loadable modules, say, ".so".]) -fi -if test "$libltdl_cv_shrext" != "$libltdl_cv_shlibext"; then - m4_pattern_allow([LT_SHARED_EXT])dnl - AC_DEFINE_UNQUOTED([LT_SHARED_EXT], ["$libltdl_cv_shrext"], - [Define to the shared library suffix, say, ".dylib".]) -fi -if test -n "$shared_archive_member_spec"; then - m4_pattern_allow([LT_SHARED_LIB_MEMBER])dnl - AC_DEFINE_UNQUOTED([LT_SHARED_LIB_MEMBER], ["($shared_archive_member_spec.o)"], - [Define to the shared archive member specification, say "(shr.o)".]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:585: -1- AU_DEFUN([AC_LTDL_SHLIBEXT], [m4_if($#, 0, [LT_SYS_MODULE_EXT], [LT_SYS_MODULE_EXT($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:585: -1- AC_DEFUN([AC_LTDL_SHLIBEXT], [m4_warn([obsolete], [The macro 'AC_LTDL_SHLIBEXT' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_MODULE_EXT], [LT_SYS_MODULE_EXT($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:592: -1- AC_DEFUN([LT_SYS_MODULE_PATH], [m4_require([_LT_SYS_DYNAMIC_LINKER])dnl -AC_CACHE_CHECK([what variable specifies run-time module search path], - [lt_cv_module_path_var], [lt_cv_module_path_var=$shlibpath_var]) -if test -n "$lt_cv_module_path_var"; then - m4_pattern_allow([LT_MODULE_PATH_VAR])dnl - AC_DEFINE_UNQUOTED([LT_MODULE_PATH_VAR], ["$lt_cv_module_path_var"], - [Define to the name of the environment variable that determines the run-time module search path.]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:604: -1- AU_DEFUN([AC_LTDL_SHLIBPATH], [m4_if($#, 0, [LT_SYS_MODULE_PATH], [LT_SYS_MODULE_PATH($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:604: -1- AC_DEFUN([AC_LTDL_SHLIBPATH], [m4_warn([obsolete], [The macro 'AC_LTDL_SHLIBPATH' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_MODULE_PATH], [LT_SYS_MODULE_PATH($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:611: -1- AC_DEFUN([LT_SYS_DLSEARCH_PATH], [m4_require([_LT_SYS_DYNAMIC_LINKER])dnl -AC_CACHE_CHECK([for the default library search path], - [lt_cv_sys_dlsearch_path], - [lt_cv_sys_dlsearch_path=$sys_lib_dlsearch_path_spec]) -if test -n "$lt_cv_sys_dlsearch_path"; then - sys_dlsearch_path= - for dir in $lt_cv_sys_dlsearch_path; do - if test -z "$sys_dlsearch_path"; then - sys_dlsearch_path=$dir - else - sys_dlsearch_path=$sys_dlsearch_path$PATH_SEPARATOR$dir - fi - done - m4_pattern_allow([LT_DLSEARCH_PATH])dnl - AC_DEFINE_UNQUOTED([LT_DLSEARCH_PATH], ["$sys_dlsearch_path"], - [Define to the system default library search path.]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:632: -1- AU_DEFUN([AC_LTDL_SYSSEARCHPATH], [m4_if($#, 0, [LT_SYS_DLSEARCH_PATH], [LT_SYS_DLSEARCH_PATH($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:632: -1- AC_DEFUN([AC_LTDL_SYSSEARCHPATH], [m4_warn([obsolete], [The macro 'AC_LTDL_SYSSEARCHPATH' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_DLSEARCH_PATH], [LT_SYS_DLSEARCH_PATH($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:658: -1- AC_DEFUN([LT_LIB_DLLOAD], [m4_pattern_allow([^LT_DLLOADERS$]) -LT_DLLOADERS= -AC_SUBST([LT_DLLOADERS]) - -AC_LANG_PUSH([C]) -lt_dlload_save_LIBS=$LIBS - -LIBADD_DLOPEN= -AC_SEARCH_LIBS([dlopen], [dl], - [AC_DEFINE([HAVE_LIBDL], [1], - [Define if you have the libdl library or equivalent.]) - if test "$ac_cv_search_dlopen" != "none required"; then - LIBADD_DLOPEN=-ldl - fi - libltdl_cv_lib_dl_dlopen=yes - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"], - [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#if HAVE_DLFCN_H -# include -#endif - ]], [[dlopen(0, 0);]])], - [AC_DEFINE([HAVE_LIBDL], [1], - [Define if you have the libdl library or equivalent.]) - libltdl_cv_func_dlopen=yes - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"], - [AC_CHECK_LIB([svld], [dlopen], - [AC_DEFINE([HAVE_LIBDL], [1], - [Define if you have the libdl library or equivalent.]) - LIBADD_DLOPEN=-lsvld libltdl_cv_func_dlopen=yes - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dlopen.la"])])]) -if test yes = "$libltdl_cv_func_dlopen" || test yes = "$libltdl_cv_lib_dl_dlopen" -then - lt_save_LIBS=$LIBS - LIBS="$LIBS $LIBADD_DLOPEN" - AC_CHECK_FUNCS([dlerror]) - LIBS=$lt_save_LIBS -fi -AC_SUBST([LIBADD_DLOPEN]) - -LIBADD_SHL_LOAD= -AC_CHECK_FUNC([shl_load], - [AC_DEFINE([HAVE_SHL_LOAD], [1], - [Define if you have the shl_load function.]) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}shl_load.la"], - [AC_CHECK_LIB([dld], [shl_load], - [AC_DEFINE([HAVE_SHL_LOAD], [1], - [Define if you have the shl_load function.]) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}shl_load.la" - LIBADD_SHL_LOAD=-ldld])]) -AC_SUBST([LIBADD_SHL_LOAD]) - -case $host_os in -darwin[[1567]].*) -# We only want this for pre-Mac OS X 10.4. - AC_CHECK_FUNC([_dyld_func_lookup], - [AC_DEFINE([HAVE_DYLD], [1], - [Define if you have the _dyld_func_lookup function.]) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dyld.la"]) - ;; -beos*) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}load_add_on.la" - ;; -cygwin* | mingw* | windows* | pw32*) - AC_CHECK_DECLS([cygwin_conv_path], [], [], [[#include ]]) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}loadlibrary.la" - ;; -esac - -AC_CHECK_LIB([dld], [dld_link], - [AC_DEFINE([HAVE_DLD], [1], - [Define if you have the GNU dld library.]) - LT_DLLOADERS="$LT_DLLOADERS ${lt_dlopen_dir+$lt_dlopen_dir/}dld_link.la"]) -AC_SUBST([LIBADD_DLD_LINK]) - -m4_pattern_allow([^LT_DLPREOPEN$]) -LT_DLPREOPEN= -if test -n "$LT_DLLOADERS" -then - for lt_loader in $LT_DLLOADERS; do - LT_DLPREOPEN="$LT_DLPREOPEN-dlpreopen $lt_loader " - done - AC_DEFINE([HAVE_LIBDLLOADER], [1], - [Define if libdlloader will be built on this platform]) -fi -AC_SUBST([LT_DLPREOPEN]) - -dnl This isn't used anymore, but set it for backwards compatibility -LIBADD_DL="$LIBADD_DLOPEN $LIBADD_SHL_LOAD" -AC_SUBST([LIBADD_DL]) - -LIBS=$lt_dlload_save_LIBS -AC_LANG_POP -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:753: -1- AU_DEFUN([AC_LTDL_DLLIB], [m4_if($#, 0, [LT_LIB_DLLOAD], [LT_LIB_DLLOAD($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:753: -1- AC_DEFUN([AC_LTDL_DLLIB], [m4_warn([obsolete], [The macro 'AC_LTDL_DLLIB' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_LIB_DLLOAD], [LT_LIB_DLLOAD($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:761: -1- AC_DEFUN([LT_SYS_SYMBOL_USCORE], [m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl -AC_CACHE_CHECK([for _ prefix in compiled symbols], - [lt_cv_sys_symbol_underscore], - [lt_cv_sys_symbol_underscore=no - cat > conftest.$ac_ext <<_LT_EOF -void nm_test_func(){} -int main(void){nm_test_func;return 0;} -_LT_EOF - if AC_TRY_EVAL(ac_compile); then - # Now try to grab the symbols. - ac_nlist=conftest.nm - if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $ac_nlist) && test -s "$ac_nlist"; then - # See whether the symbols have a leading underscore. - if grep '^. _nm_test_func' "$ac_nlist" >/dev/null; then - lt_cv_sys_symbol_underscore=yes - else - if grep '^. nm_test_func ' "$ac_nlist" >/dev/null; then - : - else - echo "configure: cannot find nm_test_func in $ac_nlist" >&AS_MESSAGE_LOG_FD - fi - fi - else - echo "configure: cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD - fi - else - echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD - cat conftest.c >&AS_MESSAGE_LOG_FD - fi - rm -rf conftest* - ]) - sys_symbol_underscore=$lt_cv_sys_symbol_underscore - AC_SUBST([sys_symbol_underscore]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:798: -1- AU_DEFUN([AC_LTDL_SYMBOL_USCORE], [m4_if($#, 0, [LT_SYS_SYMBOL_USCORE], [LT_SYS_SYMBOL_USCORE($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:798: -1- AC_DEFUN([AC_LTDL_SYMBOL_USCORE], [m4_warn([obsolete], [The macro 'AC_LTDL_SYMBOL_USCORE' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_SYS_SYMBOL_USCORE], [LT_SYS_SYMBOL_USCORE($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:805: -1- AC_DEFUN([LT_FUNC_DLSYM_USCORE], [AC_REQUIRE([_LT_COMPILER_PIC])dnl for lt_prog_compiler_wl -AC_REQUIRE([LT_SYS_SYMBOL_USCORE])dnl for lt_cv_sys_symbol_underscore -AC_REQUIRE([LT_SYS_MODULE_EXT])dnl for libltdl_cv_shlibext -if test yes = "$lt_cv_sys_symbol_underscore"; then - if test yes = "$libltdl_cv_func_dlopen" || test yes = "$libltdl_cv_lib_dl_dlopen"; then - AC_CACHE_CHECK([whether we have to add an underscore for dlsym], - [libltdl_cv_need_uscore], - [libltdl_cv_need_uscore=unknown - dlsym_uscore_save_LIBS=$LIBS - LIBS="$LIBS $LIBADD_DLOPEN" - libname=conftmod # stay within 8.3 filename limits! - cat >$libname.$ac_ext <<_LT_EOF -[#line $LINENO "configure" -#include "confdefs.h" -/* When -fvisibility=hidden is used, assume the code has been annotated - correspondingly for the symbols needed. */ -#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) -int fnord () __attribute__((visibility("default"))); -#endif -int fnord () { return 42; }] -_LT_EOF - - # ltfn_module_cmds module_cmds - # Execute tilde-delimited MODULE_CMDS with environment primed for - # $module_cmds or $archive_cmds type content. - ltfn_module_cmds () - {( # subshell avoids polluting parent global environment - module_cmds_save_ifs=$IFS; IFS='~' - for cmd in @S|@1; do - IFS=$module_cmds_save_ifs - libobjs=$libname.$ac_objext; lib=$libname$libltdl_cv_shlibext - rpath=/not-exists; soname=$libname$libltdl_cv_shlibext; output_objdir=. - major=; versuffix=; verstring=; deplibs= - ECHO=echo; wl=$lt_prog_compiler_wl; allow_undefined_flag= - eval $cmd - done - IFS=$module_cmds_save_ifs - )} - - # Compile a loadable module using libtool macro expansion results. - $CC $pic_flag -c $libname.$ac_ext - ltfn_module_cmds "${module_cmds:-$archive_cmds}" - - # Try to fetch fnord with dlsym(). - libltdl_dlunknown=0; libltdl_dlnouscore=1; libltdl_dluscore=2 - cat >conftest.$ac_ext <<_LT_EOF -[#line $LINENO "configure" -#include "confdefs.h" -#if HAVE_DLFCN_H -#include -#endif -#include -#ifndef RTLD_GLOBAL -# ifdef DL_GLOBAL -# define RTLD_GLOBAL DL_GLOBAL -# else -# define RTLD_GLOBAL 0 -# endif -#endif -#ifndef RTLD_NOW -# ifdef DL_NOW -# define RTLD_NOW DL_NOW -# else -# define RTLD_NOW 0 -# endif -#endif -int main (void) { - void *handle = dlopen ("`pwd`/$libname$libltdl_cv_shlibext", RTLD_GLOBAL|RTLD_NOW); - int status = $libltdl_dlunknown; - if (handle) { - if (dlsym (handle, "fnord")) - status = $libltdl_dlnouscore; - else { - if (dlsym (handle, "_fnord")) - status = $libltdl_dluscore; - else - puts (dlerror ()); - } - dlclose (handle); - } else - puts (dlerror ()); - return status; -}] -_LT_EOF - if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then - (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null - libltdl_status=$? - case x$libltdl_status in - x$libltdl_dlnouscore) libltdl_cv_need_uscore=no ;; - x$libltdl_dluscore) libltdl_cv_need_uscore=yes ;; - x*) libltdl_cv_need_uscore=unknown ;; - esac - fi - rm -rf conftest* $libname* - LIBS=$dlsym_uscore_save_LIBS - ]) - fi -fi - -if test yes = "$libltdl_cv_need_uscore"; then - AC_DEFINE([NEED_USCORE], [1], - [Define if dlsym() requires a leading underscore in symbol names.]) -fi -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:912: -1- AU_DEFUN([AC_LTDL_DLSYM_USCORE], [m4_if($#, 0, [LT_FUNC_DLSYM_USCORE], [LT_FUNC_DLSYM_USCORE($@)])], [], []) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltdl.m4:912: -1- AC_DEFUN([AC_LTDL_DLSYM_USCORE], [m4_warn([obsolete], [The macro 'AC_LTDL_DLSYM_USCORE' is obsolete. -You should run autoupdate.])dnl -m4_if($#, 0, [LT_FUNC_DLSYM_USCORE], [LT_FUNC_DLSYM_USCORE($@)])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:14: -1- AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:113: -1- AU_DEFUN([AC_LIBTOOL_DLOPEN], [_LT_SET_OPTION([LT_INIT], [dlopen]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'dlopen' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:113: -1- AC_DEFUN([AC_LIBTOOL_DLOPEN], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_DLOPEN' is obsolete. -You should run autoupdate.])dnl -_LT_SET_OPTION([LT_INIT], [dlopen]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'dlopen' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:148: -1- AU_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_REQUIRE([AC_CANONICAL_HOST])dnl -_LT_SET_OPTION([LT_INIT], [win32-dll]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'win32-dll' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:148: -1- AC_DEFUN([AC_LIBTOOL_WIN32_DLL], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_WIN32_DLL' is obsolete. -You should run autoupdate.])dnl -AC_REQUIRE([AC_CANONICAL_HOST])dnl -_LT_SET_OPTION([LT_INIT], [win32-dll]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'win32-dll' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:197: -1- AC_DEFUN([AC_ENABLE_SHARED], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:201: -1- AC_DEFUN([AC_DISABLE_SHARED], [_LT_SET_OPTION([LT_INIT], [disable-shared]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:205: -1- AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:205: -1- AC_DEFUN([AM_ENABLE_SHARED], [m4_warn([obsolete], [The macro 'AM_ENABLE_SHARED' is obsolete. -You should run autoupdate.])dnl -AC_ENABLE_SHARED($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:206: -1- AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:206: -1- AC_DEFUN([AM_DISABLE_SHARED], [m4_warn([obsolete], [The macro 'AM_DISABLE_SHARED' is obsolete. -You should run autoupdate.])dnl -AC_DISABLE_SHARED($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:251: -1- AC_DEFUN([AC_ENABLE_STATIC], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:255: -1- AC_DEFUN([AC_DISABLE_STATIC], [_LT_SET_OPTION([LT_INIT], [disable-static]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:259: -1- AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:259: -1- AC_DEFUN([AM_ENABLE_STATIC], [m4_warn([obsolete], [The macro 'AM_ENABLE_STATIC' is obsolete. -You should run autoupdate.])dnl -AC_ENABLE_STATIC($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:260: -1- AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:260: -1- AC_DEFUN([AM_DISABLE_STATIC], [m4_warn([obsolete], [The macro 'AM_DISABLE_STATIC' is obsolete. -You should run autoupdate.])dnl -AC_DISABLE_STATIC($@)]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:305: -1- AU_DEFUN([AC_ENABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you put -the 'fast-install' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:305: -1- AC_DEFUN([AC_ENABLE_FAST_INSTALL], [m4_warn([obsolete], [The macro 'AC_ENABLE_FAST_INSTALL' is obsolete. -You should run autoupdate.])dnl -_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you put -the 'fast-install' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:312: -1- AU_DEFUN([AC_DISABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], [disable-fast-install]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you put -the 'disable-fast-install' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:312: -1- AC_DEFUN([AC_DISABLE_FAST_INSTALL], [m4_warn([obsolete], [The macro 'AC_DISABLE_FAST_INSTALL' is obsolete. -You should run autoupdate.])dnl -_LT_SET_OPTION([LT_INIT], [disable-fast-install]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you put -the 'disable-fast-install' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:441: -1- AU_DEFUN([AC_LIBTOOL_PICMODE], [_LT_SET_OPTION([LT_INIT], [pic-only]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'pic-only' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltoptions.m4:441: -1- AC_DEFUN([AC_LIBTOOL_PICMODE], [m4_warn([obsolete], [The macro 'AC_LIBTOOL_PICMODE' is obsolete. -You should run autoupdate.])dnl -_LT_SET_OPTION([LT_INIT], [pic-only]) -AC_DIAGNOSE([obsolete], -[$0: Remove this warning and the call to _LT_SET_OPTION when you -put the 'pic-only' option into LT_INIT's first parameter.]) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltsugar.m4:14: -1- AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/ltversion.m4:19: -1- AC_DEFUN([LTVERSION_VERSION], [macro_version='2.5.4-redox-9510' -macro_revision='2.5.4' -_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) -_LT_DECL(, macro_revision, 0) -]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:37: -1- AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:41: -1- AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:42: -1- AC_DEFUN([_LT_AC_SHELL_INIT]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:43: -1- AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:45: -1- AC_DEFUN([_LT_AC_TAGVAR]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:46: -1- AC_DEFUN([AC_LTDL_ENABLE_INSTALL]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:47: -1- AC_DEFUN([AC_LTDL_PREOPEN]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:48: -1- AC_DEFUN([_LT_AC_SYS_COMPILER]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:49: -1- AC_DEFUN([_LT_AC_LOCK]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:50: -1- AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:51: -1- AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:52: -1- AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:53: -1- AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:54: -1- AC_DEFUN([AC_LIBTOOL_OBJDIR]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:55: -1- AC_DEFUN([AC_LTDL_OBJDIR]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:56: -1- AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:57: -1- AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:58: -1- AC_DEFUN([AC_PATH_MAGIC]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:59: -1- AC_DEFUN([AC_PROG_LD_GNU]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:60: -1- AC_DEFUN([AC_PROG_LD_RELOAD_FLAG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:61: -1- AC_DEFUN([AC_DEPLIBS_CHECK_METHOD]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:62: -1- AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:63: -1- AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:64: -1- AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:65: -1- AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:66: -1- AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:67: -1- AC_DEFUN([LT_AC_PROG_EGREP]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:68: -1- AC_DEFUN([LT_AC_PROG_SED]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:72: -1- AC_DEFUN([_AC_PROG_LIBTOOL]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:73: -1- AC_DEFUN([AC_LIBTOOL_SETUP]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:74: -1- AC_DEFUN([_LT_AC_CHECK_DLFCN]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:75: -1- AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:76: -1- AC_DEFUN([_LT_AC_TAGCONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:78: -1- AC_DEFUN([_LT_AC_LANG_CXX]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:79: -1- AC_DEFUN([_LT_AC_LANG_F77]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:80: -1- AC_DEFUN([_LT_AC_LANG_GCJ]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:81: -1- AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:82: -1- AC_DEFUN([_LT_AC_LANG_C_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:83: -1- AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:84: -1- AC_DEFUN([_LT_AC_LANG_CXX_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:85: -1- AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:86: -1- AC_DEFUN([_LT_AC_LANG_F77_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:87: -1- AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:88: -1- AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:89: -1- AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:90: -1- AC_DEFUN([_LT_AC_LANG_RC_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:91: -1- AC_DEFUN([AC_LIBTOOL_CONFIG]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:92: -1- AC_DEFUN([_LT_AC_FILE_LTDLL_C]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:94: -1- AC_DEFUN([_LT_AC_PROG_CXXCPP]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:97: -1- AC_DEFUN([_LT_PROG_F77]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:98: -1- AC_DEFUN([_LT_PROG_FC]) -m4trace:/mnt/data/homes/kellito/Builds/rbos/prefix/x86_64-unknown-redox/sysroot/share/aclocal/lt~obsolete.m4:99: -1- AC_DEFUN([_LT_PROG_CXX]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?A[CHUM]_]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([_AC_]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([^LIBOBJS$], [do not use LIBOBJS directly, use AC_LIBOBJ (see section 'AC_LIBOBJ vs LIBOBJS']) -m4trace:configure.ac:20: -1- m4_pattern_allow([^AS_FLAGS$]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?m4_]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([^dnl$]) -m4trace:configure.ac:20: -1- m4_pattern_forbid([^_?AS_]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^SHELL$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PATH_SEPARATOR$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_NAME$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_VERSION$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_STRING$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_URL$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^exec_prefix$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^prefix$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^program_transform_name$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^bindir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^sbindir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^libexecdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^datarootdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^datadir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^sysconfdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^sharedstatedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^localstatedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^runstatedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^includedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^oldincludedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^docdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^infodir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^htmldir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^dvidir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^pdfdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^psdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^libdir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^localedir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^mandir$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_NAME$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_TARNAME$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_VERSION$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_STRING$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_BUGREPORT$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^PACKAGE_URL$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^DEFS$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_C$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_N$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^ECHO_T$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^LIBS$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^build_alias$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^host_alias$]) -m4trace:configure.ac:20: -1- m4_pattern_allow([^target_alias$]) -m4trace:configure.ac:25: -1- AM_INIT_AUTOMAKE([1.11.1 silent-rules parallel-tests]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AM_[A-Z]+FLAGS$]) -m4trace:configure.ac:25: -1- AM_SET_CURRENT_AUTOMAKE_VERSION -m4trace:configure.ac:25: -1- AM_AUTOMAKE_VERSION([1.18.1]) -m4trace:configure.ac:25: -1- _AM_AUTOCONF_VERSION([2.72]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_PROGRAM$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_SCRIPT$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_DATA$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^am__isrc$]) -m4trace:configure.ac:25: -1- _AM_SUBST_NOTMAKE([am__isrc]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^CYGPATH_W$]) -m4trace:configure.ac:25: -1- _AM_SET_OPTIONS([1.11.1 silent-rules parallel-tests]) -m4trace:configure.ac:25: -1- _AM_SET_OPTION([1.11.1]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([1.11.1]) -m4trace:configure.ac:25: -1- _AM_SET_OPTION([silent-rules]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([silent-rules]) -m4trace:configure.ac:25: -1- _AM_SET_OPTION([parallel-tests]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([parallel-tests]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^PACKAGE$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^VERSION$]) -m4trace:configure.ac:25: -1- _AM_IF_OPTION([no-define], [], [AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) - AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([no-define]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^PACKAGE$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^VERSION$]) -m4trace:configure.ac:25: -1- AM_SANITY_CHECK -m4trace:configure.ac:25: -1- _AM_FILESYSTEM_TIMESTAMP_RESOLUTION -m4trace:configure.ac:25: -1- _AM_SLEEP_FRACTIONAL_SECONDS -m4trace:configure.ac:25: -1- AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) -m4trace:configure.ac:25: -1- AM_MISSING_HAS_RUN -m4trace:configure.ac:25: -1- AM_AUX_DIR_EXPAND -m4trace:configure.ac:25: -1- m4_pattern_allow([^ACLOCAL$]) -m4trace:configure.ac:25: -1- AM_MISSING_PROG([AUTOCONF], [autoconf]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOCONF$]) -m4trace:configure.ac:25: -1- AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOMAKE$]) -m4trace:configure.ac:25: -1- AM_MISSING_PROG([AUTOHEADER], [autoheader]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AUTOHEADER$]) -m4trace:configure.ac:25: -1- AM_MISSING_PROG([MAKEINFO], [makeinfo]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^MAKEINFO$]) -m4trace:configure.ac:25: -1- AM_PROG_INSTALL_SH -m4trace:configure.ac:25: -1- m4_pattern_allow([^install_sh$]) -m4trace:configure.ac:25: -1- AM_PROG_INSTALL_STRIP -m4trace:configure.ac:25: -1- m4_pattern_allow([^STRIP$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^INSTALL_STRIP_PROGRAM$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^MKDIR_P$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^mkdir_p$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AWK$]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^SET_MAKE$]) -m4trace:configure.ac:25: -1- AM_SET_LEADING_DOT -m4trace:configure.ac:25: -1- m4_pattern_allow([^am__leading_dot$]) -m4trace:configure.ac:25: -1- _AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], - [_AM_IF_OPTION([tar-v7], [_AM_PROG_TAR([v7])], - [_AM_PROG_TAR([ustar])])])]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([tar-ustar]) -m4trace:configure.ac:25: -1- _AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], [_AM_IF_OPTION([tar-v7], [_AM_PROG_TAR([v7])], - [_AM_PROG_TAR([ustar])])]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([tar-pax]) -m4trace:configure.ac:25: -1- _AM_IF_OPTION([tar-v7], [_AM_PROG_TAR([v7])], [_AM_PROG_TAR([ustar])]) -m4trace:configure.ac:25: -2- _AM_MANGLE_OPTION([tar-v7]) -m4trace:configure.ac:25: -1- _AM_PROG_TAR([ustar]) -m4trace:configure.ac:25: -1- m4_pattern_allow([^AMTAR$]) -m4trace:configure.ac:25: -1- AM_RUN_LOG([$_am_tar --version]) -m4trace:configure.ac:25: -1- AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) -m4trace:configure.ac:25: -1- AM_RUN_LOG([$am__untar &5 2>&1 && - (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], [:]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGFMT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^GMSGFMT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^GMSGFMT_015$]) -m4trace:configure.ac:111: -1- AM_PATH_PROG_WITH_TEST([XGETTEXT], [xgettext], [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&5 2>&1 && - (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], [:]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT_015$]) -m4trace:configure.ac:111: -1- AM_PATH_PROG_WITH_TEST([MSGMERGE], [msgmerge], [$ac_dir/$ac_word --update -q /dev/null /dev/null >&5 2>&1], [:]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGMERGE$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^MSGMERGE_FOR_MSGFMT_OPTION$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^XGETTEXT_EXTRA_OPTIONS$]) -m4trace:configure.ac:111: -1- AC_LIB_PREPARE_PREFIX -m4trace:configure.ac:111: -1- AC_LIB_RPATH -m4trace:configure.ac:111: -1- AC_LIB_PROG_LD -m4trace:configure.ac:111: -1- AC_LIB_PROG_LD_GNU -m4trace:configure.ac:111: -1- gt_INTL_MACOSX -m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_CFPREFERENCESCOPYAPPVALUE$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_CFLOCALECOPYPREFERREDLANGUAGES$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^INTL_MACOSX_LIBS$]) -m4trace:configure.ac:111: -1- AC_LIB_LINKFLAGS_BODY([intl]) -m4trace:configure.ac:111: -1- AC_LIB_PREPARE_MULTILIB -m4trace:configure.ac:111: -1- gl_HOST_CPU_C_ABI_32BIT -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^ENABLE_NLS$]) -m4trace:configure.ac:111: -1- AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) -m4trace:configure.ac:111: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_GETTEXT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^HAVE_DCGETTEXT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^USE_INCLUDED_LIBINTL$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^CATOBJEXT$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^LIBINTL$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^LTLIBINTL$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^POSUB$]) -m4trace:configure.ac:111: -1- gl_BUILD_TO_HOST([localedir]) -m4trace:configure.ac:111: -1- gl_BUILD_TO_HOST_INIT -m4trace:configure.ac:111: -1- m4_pattern_allow([^localedir_c$]) -m4trace:configure.ac:111: -1- m4_pattern_allow([^localedir_c_make$]) -m4trace:configure.ac:114: -1- gl_INIT -m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_LIBTOOL], [false]) -m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_LIBTOOL_TRUE$]) -m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_LIBTOOL_FALSE$]) -m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_LIBTOOL_TRUE]) -m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_LIBTOOL_FALSE]) -m4trace:configure.ac:114: -1- gl_COMMON -m4trace:configure.ac:114: -1- gl_00GNULIB -m4trace:configure.ac:114: -1- gl_COMMON_BODY -m4trace:configure.ac:114: -1- gl_ZZGNULIB -m4trace:configure.ac:114: -1- gl_ALIGNASOF -m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C_ALIGNASOF$]) -m4trace:configure.ac:114: -1- gl_FUNC_ALLOCA +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([size_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^size_t$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([size_t], [/* Define as \'unsigned int\' if doesn\'t define. */ +@%:@undef size_t]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ALLOCA_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ALLOCA_H$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ALLOCA_H], [/* Define to 1 if works. */ +@%:@undef HAVE_ALLOCA_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ALLOCA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ALLOCA$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ALLOCA], [/* Define to 1 if you have \'alloca\', as a function or macro. */ +@%:@undef HAVE_ALLOCA]) +m4trace:configure.ac:114: -1- AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.$ac_objext]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ALLOCA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ALLOCA$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([C_ALLOCA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^C_ALLOCA$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([C_ALLOCA], [/* Define to 1 if using \'alloca.c\'. */ +@%:@undef C_ALLOCA]) +m4trace:configure.ac:114: -1- AH_OUTPUT([STACK_DIRECTION], [/* If using the C implementation of alloca, define if you know the + direction of stack growth for your system; otherwise it will be + automatically deduced at runtime. + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown */ +#undef STACK_DIRECTION]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([STACK_DIRECTION]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STACK_DIRECTION$]) -m4trace:configure.ac:114: -1- gl_PREREQ_ALLOCA +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ALLOCA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ALLOCA$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ALLOCA], [/* Define to 1 if you have \'alloca\' after including , a header that + may be supplied by this distribution. */ +@%:@undef HAVE_ALLOCA]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ALLOCA_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ALLOCA_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ALLOCA_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([alloca.h]) +m4trace:configure.ac:114: -1- AC_SUBST([ALLOCA_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ALLOCA_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ALLOCA_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_ALLOCA_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_ALLOCA_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ALLOCA_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ALLOCA_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ALLOCA_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ALLOCA_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ALLOCA_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ALLOCA_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ALLOCA_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ALLOCA_H_FALSE]) -m4trace:configure.ac:114: -1- gl_ASSERT_H +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_C_STATIC_ASSERT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C_STATIC_ASSERT$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([assert.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([assert.h], [assume]) -m4trace:configure.ac:114: -1- gl_INCLUDE_NEXT +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_C_STATIC_ASSERT], [/* Define to 1 if the static_assert keyword works. */ +@%:@undef HAVE_C_STATIC_ASSERT]) +m4trace:configure.ac:114: -1- AC_SUBST([INCLUDE_NEXT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([INCLUDE_NEXT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INCLUDE_NEXT$]) +m4trace:configure.ac:114: -1- AC_SUBST([INCLUDE_NEXT_AS_FIRST_DIRECTIVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([INCLUDE_NEXT_AS_FIRST_DIRECTIVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INCLUDE_NEXT_AS_FIRST_DIRECTIVE$]) +m4trace:configure.ac:114: -1- AC_SUBST([PRAGMA_SYSTEM_HEADER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([PRAGMA_SYSTEM_HEADER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PRAGMA_SYSTEM_HEADER$]) +m4trace:configure.ac:114: -1- AC_SUBST([PRAGMA_COLUMNS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([PRAGMA_COLUMNS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PRAGMA_COLUMNS$]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([assert.h]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_ASSERT_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_ASSERT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_ASSERT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_ASSERT_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_ASSERT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_ASSERT_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([assert.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([zzstatic_assert], [#if (!defined HAVE_C_STATIC_ASSERT && !defined assert \\ + && (!defined __cplusplus \\ + || (__cpp_static_assert < 201411 \\ + && __GNUG__ < 6 && __clang_major__ < 6))) + #include + #undef/**/assert + #ifdef __sgi + #undef/**/__ASSERT_H__ + #endif + /* Solaris 11.4 defines static_assert as a macro with 2 arguments. + We need it also to be invocable with a single argument. */ + #if defined __sun && (__STDC_VERSION__ - 0 >= 201112L) && !defined __cplusplus + #undef/**/static_assert + #define static_assert _Static_assert + #endif +#endif]) +m4trace:configure.ac:114: -1- AC_SUBST([ASSERT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ASSERT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ASSERT_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_ASSERT_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_ASSERT_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ASSERT_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ASSERT_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ASSERT_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ASSERT_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ASSERT_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ASSERT_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ASSERT_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ASSERT_H_FALSE]) -m4trace:configure.ac:114: -1- gl_FUNC_ATEXIT +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ATEXIT], [/* Define to 1 if you have the \'atexit\' function. */ +@%:@undef HAVE_ATEXIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ATEXIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ATEXIT$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ATEXIT], [test $ac_cv_func_atexit = no]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ATEXIT], [test $ac_cv_func_atexit = no]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ATEXIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ATEXIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ATEXIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ATEXIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ATEXIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ATEXIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ATEXIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ATEXIT_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_ATEXIT], [ - gl_PREREQ_ATEXIT - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_ATEXIT -m4trace:configure.ac:114: -1- gl___BUILTIN_EXPECT +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_ATEXIT]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_ATEXIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE___BUILTIN_EXPECT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE___BUILTIN_EXPECT$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE___BUILTIN_EXPECT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE___BUILTIN_EXPECT$]) -m4trace:configure.ac:114: -1- gl_UCHAR_H -m4trace:configure.ac:114: -1- gl_UCHAR_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE___BUILTIN_EXPECT], [/* Define to 1 if the compiler supports __builtin_expect, + and to 2 if does. */ +#undef HAVE___BUILTIN_EXPECT +#ifndef HAVE___BUILTIN_EXPECT +# define __builtin_expect(e, c) (e) +#elif HAVE___BUILTIN_EXPECT == 2 +# include +#endif + ]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_C32RTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_C32RTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C32RTOMB$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBRTOC16]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBRTOC16]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBRTOC16$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBRTOC32$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_C32RTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_C32RTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_C32RTOMB$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBRTOC16]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBRTOC16]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBRTOC16$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBRTOC32$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([uchar.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([uchar.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_uchar_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" uchar.h ]AS_TR_SH([uchar.h]) AS_TR_CPP([HAVE_uchar.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([uchar.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UCHAR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_UCHAR_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_UCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_UCHAR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_UCHAR_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_UCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_UCHAR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UCHAR_H$]) -m4trace:configure.ac:114: -1- gl_TYPE_CHAR8_T +m4trace:configure.ac:114: -1- AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR8_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GNULIBHEADERS_OVERRIDE_CHAR8_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIBHEADERS_OVERRIDE_CHAR8_T$]) -m4trace:configure.ac:114: -1- gl_TYPE_CHAR16_T +m4trace:configure.ac:114: -1- AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR16_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GNULIBHEADERS_OVERRIDE_CHAR16_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIBHEADERS_OVERRIDE_CHAR16_T$]) -m4trace:configure.ac:114: -1- gl_TYPE_CHAR32_T +m4trace:configure.ac:114: -1- AC_SUBST([GNULIBHEADERS_OVERRIDE_CHAR32_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GNULIBHEADERS_OVERRIDE_CHAR32_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIBHEADERS_OVERRIDE_CHAR32_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([CXX_HAS_UCHAR_TYPES]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([CXX_HAS_UCHAR_TYPES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^CXX_HAS_UCHAR_TYPES$]) +m4trace:configure.ac:114: -1- AC_SUBST([CXX_HAS_CHAR8_TYPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([CXX_HAS_CHAR8_TYPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^CXX_HAS_CHAR8_TYPE$]) -m4trace:configure.ac:114: -1- gl_STDINT_BITSIZEOF([wchar_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_WCHAR_T], [/* Define to the number of bits in type \'wchar_t\'. */ +@%:@undef BITSIZEOF_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_WCHAR_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([SMALL_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SMALL_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SMALL_WCHAR_T$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[ - #ifdef __HAIKU__ - #include - #endif - #include - ]], [c32rtomb mbrtoc16 mbrtoc32]) -m4trace:configure.ac:114: -1- gl_MBSTATE_T_BROKEN -m4trace:configure.ac:114: -1- gl_WCHAR_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_BTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_BTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_BTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBSINIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBSINIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBSINIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBRTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBRLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBRLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBRLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBSRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBSRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBSRTOWCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBSNRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBSNRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBSNRTOWCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCRTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCRTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCRTOMB$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSRTOMBS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNRTOMBS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMMOVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMMOVE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WMEMSET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WMEMSET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WMEMSET$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCPNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCPNCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNCAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCASECMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSNCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSNCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSNCASECMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCOLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSXFRM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSXFRM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSXFRM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSRCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSRCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSCSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSCSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSCSPN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSSPN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSPBRK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSPBRK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSSTR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSTOK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSTOK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSTOK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSWIDTH$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCSFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCSFTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCSFTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_WCTOB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_WCTOB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_WCTOB$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_WCSDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_WCSDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_WCSDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_WCWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_WCWIDTH$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBSTATE_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBSTATE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBSTATE_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_BTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_BTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_BTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCTOB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCTOB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCTOB$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBSINIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBSINIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBSINIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBRTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBRLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBRLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBRLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBSRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBSRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBSRTOWCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBSNRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBSNRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBSNRTOWCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCRTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCRTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCRTOMB$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSRTOMBS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSNRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSNRTOMBS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCWIDTH$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSWIDTH$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSFTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSFTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSNCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSNCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSNCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSSTR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCSTOK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCSTOK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCSTOK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WMEMCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WMEMCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WMEMCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WMEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WMEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WMEMPCPY$]) -m4trace:configure.ac:114: -1- AC_TYPE_MBSTATE_T +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MBSTATE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBSTATE_T$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBSTATE_T], [/* Define to 1 if declares mbstate_t. */ +@%:@undef HAVE_MBSTATE_T]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([mbstate_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^mbstate_t$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mbsinit], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mbsinit ]AS_TR_CPP([HAVE_mbsinit])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mbrtowc], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mbrtowc ]AS_TR_CPP([HAVE_mbrtowc])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_MBRTOWC_INCOMPLETE_STATE -m4trace:configure.ac:114: -1- gt_LOCALE_JA -m4trace:configure.ac:114: -1- AM_LANGINFO_CODESET +m4trace:configure.ac:114: -1- AH_OUTPUT([mbstate_t], [/* Define to a type if does not define. */ +@%:@undef mbstate_t]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBSINIT], [/* Define to 1 if you have the \'mbsinit\' function. */ +@%:@undef HAVE_MBSINIT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBRTOWC], [/* Define to 1 if you have the \'mbrtowc\' function. */ +@%:@undef HAVE_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_LANGINFO_CODESET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_CODESET$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LANGINFO_CODESET], [/* Define if you have and nl_langinfo(CODESET). */ +@%:@undef HAVE_LANGINFO_CODESET]) +m4trace:configure.ac:114: -1- AC_SUBST([LOCALE_JA]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALE_JA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALE_JA$]) -m4trace:configure.ac:114: -1- gt_LOCALE_FR_UTF8 +m4trace:configure.ac:114: -1- AC_SUBST([LOCALE_FR_UTF8]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALE_FR_UTF8]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALE_FR_UTF8$]) +m4trace:configure.ac:114: -1- AC_SUBST([LC_COLLATE_IMPLEMENTED]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LC_COLLATE_IMPLEMENTED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LC_COLLATE_IMPLEMENTED$]) +m4trace:configure.ac:114: -1- AC_SUBST([LC_NUMERIC_IMPLEMENTED]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LC_NUMERIC_IMPLEMENTED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LC_NUMERIC_IMPLEMENTED$]) +m4trace:configure.ac:114: -1- AC_SUBST([LC_TIME_IMPLEMENTED]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LC_TIME_IMPLEMENTED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LC_TIME_IMPLEMENTED$]) +m4trace:configure.ac:114: -1- AC_SUBST([LC_MONETARY_IMPLEMENTED]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LC_MONETARY_IMPLEMENTED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LC_MONETARY_IMPLEMENTED$]) -m4trace:configure.ac:114: -1- gl_MBRTOWC_SANITYCHECK -m4trace:configure.ac:114: -1- gt_LOCALE_ZH_CN +m4trace:configure.ac:114: -1- AC_SUBST([LOCALE_ZH_CN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALE_ZH_CN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALE_ZH_CN$]) -m4trace:configure.ac:114: -1- gl_MBRTOC32_SANITYCHECK -m4trace:configure.ac:114: -1- gl_CHECK_FUNC_MBRTOC32 -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gt_LOCALE_FR +m4trace:configure.ac:114: -1- AC_SUBST([LOCALE_FR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALE_FR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALE_FR$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WORKING_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WORKING_MBRTOC32$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WORKING_MBRTOC32], [/* Define if the mbrtoc32 function basically works. */ +@%:@undef HAVE_WORKING_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WORKING_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WORKING_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WORKING_MBRTOC32$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isalnum]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_BTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_BTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_BTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_BTOC32$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISALNUM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISALNUM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISALNUM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISALNUM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISALPHA]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISALPHA]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISALPHA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISALPHA$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISBLANK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISCNTRL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISCNTRL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISCNTRL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISCNTRL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISDIGIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISGRAPH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISGRAPH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISGRAPH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISGRAPH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISLOWER$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISPRINT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISPRINT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISPRINT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISPRINT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISPUNCT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISPUNCT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISPUNCT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISPUNCT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISSPACE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISSPACE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISSPACE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISSPACE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISUPPER]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISUPPER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISUPPER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISUPPER$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32ISXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32ISXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32ISXDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32ISXDIGIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32TOLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32TOLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32TOLOWER$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOUPPER]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32TOUPPER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32TOUPPER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32TOUPPER$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32WIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32WIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32WIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32WIDTH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32RTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32RTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32RTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32RTOMB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32SNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32SNRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32SNRTOMBS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32SRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32SRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32SRTOMBS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32STOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32STOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32STOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32STOMBS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32SWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32SWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32SWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32SWIDTH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32TOB]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32TOB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32TOB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32TOB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_APPLY_MAPPING]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32_APPLY_MAPPING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32_APPLY_MAPPING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32_APPLY_MAPPING$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_APPLY_TYPE_TEST]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32_APPLY_TYPE_TEST]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32_APPLY_TYPE_TEST]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32_APPLY_TYPE_TEST$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_GET_MAPPING]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32_GET_MAPPING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32_GET_MAPPING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32_GET_MAPPING$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_C32_GET_TYPE_TEST]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_C32_GET_TYPE_TEST]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_C32_GET_TYPE_TEST]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_C32_GET_TYPE_TEST$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOC16]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBRTOC16]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBRTOC16]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBRTOC16$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBRTOC32$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNRTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSNRTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSNRTOC32S]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSNRTOC32S$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSRTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSRTOC32S]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSRTOC32S$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSTOC32S]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSTOC32S]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSTOC32S$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isalnum]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isalnum]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isalnum]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISALNUM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISALNUM$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isalpha]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isalpha]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isalpha]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isalpha]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISALNUM], [/* Define to 1 when the gnulib module c32isalnum should be tested. */ +@%:@undef GNULIB_TEST_C32ISALNUM]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISALPHA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISALPHA$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isblank]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isblank]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isblank]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isblank]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISALPHA], [/* Define to 1 when the gnulib module c32isalpha should be tested. */ +@%:@undef GNULIB_TEST_C32ISALPHA]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISBLANK$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32iscntrl]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32iscntrl]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32iscntrl]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32iscntrl]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISBLANK], [/* Define to 1 when the gnulib module c32isblank should be tested. */ +@%:@undef GNULIB_TEST_C32ISBLANK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISCNTRL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISCNTRL$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isdigit]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isdigit]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isdigit]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isdigit]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISCNTRL], [/* Define to 1 when the gnulib module c32iscntrl should be tested. */ +@%:@undef GNULIB_TEST_C32ISCNTRL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISDIGIT$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isgraph]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isgraph]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isgraph]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isgraph]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISDIGIT], [/* Define to 1 when the gnulib module c32isdigit should be tested. */ +@%:@undef GNULIB_TEST_C32ISDIGIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISGRAPH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISGRAPH$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32islower]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32islower]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32islower]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32islower]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISGRAPH], [/* Define to 1 when the gnulib module c32isgraph should be tested. */ +@%:@undef GNULIB_TEST_C32ISGRAPH]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISLOWER$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isprint]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isprint]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isprint]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isprint]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISLOWER], [/* Define to 1 when the gnulib module c32islower should be tested. */ +@%:@undef GNULIB_TEST_C32ISLOWER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISPRINT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISPRINT$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32ispunct]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32ispunct]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32ispunct]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32ispunct]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISPRINT], [/* Define to 1 when the gnulib module c32isprint should be tested. */ +@%:@undef GNULIB_TEST_C32ISPRINT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISPUNCT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISPUNCT$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isspace]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isspace]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isspace]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isspace]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISPUNCT], [/* Define to 1 when the gnulib module c32ispunct should be tested. */ +@%:@undef GNULIB_TEST_C32ISPUNCT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISSPACE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISSPACE$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isupper]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isupper]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isupper]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isupper]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISSPACE], [/* Define to 1 when the gnulib module c32isspace should be tested. */ +@%:@undef GNULIB_TEST_C32ISSPACE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISUPPER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISUPPER$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32isxdigit]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32isxdigit]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32isxdigit]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32isxdigit]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISUPPER], [/* Define to 1 when the gnulib module c32isupper should be tested. */ +@%:@undef GNULIB_TEST_C32ISUPPER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32ISXDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32ISXDIGIT$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32tolower]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32tolower]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32tolower]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32tolower]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32ISXDIGIT], [/* Define to 1 when the gnulib module c32isxdigit should be tested. */ +@%:@undef GNULIB_TEST_C32ISXDIGIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32TOLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32TOLOWER$]) -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([c32width]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([c32width]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[c32width]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([c32width]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32TOLOWER], [/* Define to 1 when the gnulib module c32tolower should be tested. */ +@%:@undef GNULIB_TEST_C32TOLOWER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_C32WIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_C32WIDTH$]) -m4trace:configure.ac:114: -1- gl_FUNC_CALLOC_GNU -m4trace:configure.ac:114: -1- gl_STDLIB_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_C32WIDTH], [/* Define to 1 when the gnulib module c32width should be tested. */ +@%:@undef GNULIB_TEST_C32WIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE__EXIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE__EXIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE__EXIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ALIGNED_ALLOC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ALIGNED_ALLOC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ALIGNED_ALLOC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ATOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ATOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ATOLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_CANONICALIZE_FILE_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_CANONICALIZE_FILE_NAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_ECVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_ECVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_ECVT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FCVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FCVT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GCVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GCVT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETLOADAVG]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETLOADAVG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETLOADAVG$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_PROGRAM_INVOCATION_NAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_PROGRAM_INVOCATION_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_NAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETPROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETPROGNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETSUBOPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETSUBOPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETSUBOPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GRANTPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GRANTPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GRANTPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_INITSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_INITSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_INITSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_INITSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_INITSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_INITSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKDTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKDTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKDTEMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKOSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKOSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKOSTEMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKOSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKOSTEMPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKOSTEMPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKSTEMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKSTEMPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKSTEMPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_POSIX_MEMALIGN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_POSIX_MEMALIGN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_POSIX_MEMALIGN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_POSIX_OPENPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_POSIX_OPENPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_POSIX_OPENPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PTSNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PTSNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTSNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PTSNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PTSNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTSNAME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_QSORT_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_QSORT_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_QSORT_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RANDOM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RANDOM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RANDOM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RANDOM_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RANDOM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RANDOM_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RANDOM_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RANDOM_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RANDOM_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_REALLOCARRAY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_REALPATH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_REALPATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_REALPATH$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RPMATCH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RPMATCH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RPMATCH$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SECURE_GETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SECURE_GETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SECURE_GETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_SETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_SETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_SETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SETSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SETSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SETSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_SETSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_SETSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_SETSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOLD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOLD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOLD$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOUL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRTOULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRTOULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOULL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRUCT_RANDOM_DATA]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRUCT_RANDOM_DATA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_RANDOM_DATA$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_LOADAVG_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_LOADAVG_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_LOADAVG_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UNLOCKPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UNLOCKPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNLOCKPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_UNSETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_UNSETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_UNSETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE__EXIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE__EXIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE__EXIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ALIGNED_ALLOC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ALIGNED_ALLOC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ALIGNED_ALLOC$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CALLOC_FOR_CALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CALLOC_FOR_CALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CALLOC_FOR_CALLOC_GNU$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CALLOC_FOR_CALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CALLOC_FOR_CALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CALLOC_FOR_CALLOC_POSIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CANONICALIZE_FILE_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CANONICALIZE_FILE_NAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FREE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FREE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FREE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETLOADAVG]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETLOADAVG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETLOADAVG$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETPROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETPROGNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETSUBOPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETSUBOPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETSUBOPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_INITSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_INITSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_INITSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MALLOC_FOR_MALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MALLOC_FOR_MALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MALLOC_FOR_MALLOC_GNU$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MALLOC_FOR_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MALLOC_FOR_MALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MALLOC_FOR_MALLOC_POSIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MB_CUR_MAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MB_CUR_MAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MB_CUR_MAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBSTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBSTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBSTOWCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MBTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MBTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MBTOWC$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKOSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKOSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKOSTEMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKOSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKOSTEMPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKOSTEMPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKSTEMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_POSIX_MEMALIGN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_POSIX_MEMALIGN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_POSIX_MEMALIGN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_POSIX_OPENPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_POSIX_OPENPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_POSIX_OPENPT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PTSNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PTSNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PTSNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PTSNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PTSNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PTSNAME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PUTENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PUTENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PUTENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_QSORT_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_QSORT_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_QSORT_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RAND]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RAND]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RAND$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RANDOM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RANDOM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RANDOM$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RANDOM_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RANDOM_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RANDOM_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_REALLOC_FOR_REALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_REALLOC_FOR_REALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_REALLOC_FOR_REALLOC_GNU$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_REALLOC_FOR_REALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_REALLOC_FOR_REALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_REALLOC_FOR_REALLOC_POSIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_REALLOCARRAY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_REALPATH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_REALPATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_REALPATH$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SETSTATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SETSTATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SETSTATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOLD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOLD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOLD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOUL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOULL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_UNSETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_UNSETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_UNSETENV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCTOMB$]) -m4trace:configure.ac:114: -1- gl_FUNC_CALLOC_POSIX -m4trace:configure.ac:114: -1- gl_FUNC_MALLOC_POSIX -m4trace:configure.ac:114: -1- gl_FUNC_MALLOC_PTRDIFF -m4trace:configure.ac:114: -1- gl_CHECK_MALLOC_PTRDIFF -m4trace:configure.ac:114: -1- gl_CHECK_MALLOC_POSIX +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MALLOC_POSIX$]) -m4trace:configure.ac:114: -1- _AC_FUNC_CALLOC_IF([], [REPLACE_CALLOC_FOR_CALLOC_GNU=1]) -m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:2979: AC_RUN_IFELSE is expanded from... -lib/m4sugar/m4sh.m4:690: _AS_IF_ELSE is expanded from... -lib/m4sugar/m4sh.m4:697: AS_IF is expanded from... -./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from... -./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from... +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MALLOC_POSIX], [/* Define if malloc, realloc, and calloc set errno on allocation failure. */ +@%:@undef HAVE_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:3037: AC_RUN_IFELSE is expanded from... +lib/m4sugar/m4sh.m4:689: _AS_IF_ELSE is expanded from... +lib/m4sugar/m4sh.m4:696: AS_IF is expanded from... +./lib/autoconf/general.m4:2305: AC_CACHE_VAL is expanded from... +./lib/autoconf/general.m4:2326: AC_CACHE_CHECK is expanded from... gnulib-m4/calloc.m4:18: _AC_FUNC_CALLOC_IF is expanded from... gnulib-m4/calloc.m4:57: gl_FUNC_CALLOC_GNU is expanded from... gnulib-m4/gnulib-comp.m4:253: gl_INIT is expanded from... configure.ac:114: the top level]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([calloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([calloc-gnu]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB__EXIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB__EXIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB__EXIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB__EXIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ALIGNED_ALLOC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ALIGNED_ALLOC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ALIGNED_ALLOC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ALIGNED_ALLOC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ATOLL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ATOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ATOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ATOLL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CANONICALIZE_FILE_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CANONICALIZE_FILE_NAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREE_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FREE_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FREE_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FREE_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOADAVG]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETLOADAVG]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETLOADAVG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETLOADAVG$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETPROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETPROGNAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETSUBOPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETSUBOPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETSUBOPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETSUBOPT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GRANTPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GRANTPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GRANTPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GRANTPT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSTOWCS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBTOWC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKDTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKDTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKDTEMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKOSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKOSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKOSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKOSTEMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKOSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKOSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKOSTEMPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKOSTEMPS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKSTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKSTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKSTEMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKSTEMPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKSTEMPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKSTEMPS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POSIX_MEMALIGN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_POSIX_MEMALIGN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_POSIX_MEMALIGN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_POSIX_MEMALIGN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POSIX_OPENPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_POSIX_OPENPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_POSIX_OPENPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_POSIX_OPENPT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTSNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PTSNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PTSNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PTSNAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTSNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PTSNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PTSNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PTSNAME_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTENV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PUTENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PUTENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PUTENV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_QSORT_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_QSORT_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_QSORT_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_QSORT_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAND]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RAND]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RAND]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RAND$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RANDOM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RANDOM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RANDOM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RANDOM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RANDOM_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RANDOM_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RANDOM_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RANDOM_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_REALLOCARRAY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_REALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_REALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_REALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_REALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_REALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_REALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REALPATH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_REALPATH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_REALPATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_REALPATH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RPMATCH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RPMATCH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RPMATCH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RPMATCH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SECURE_GETENV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SECURE_GETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SECURE_GETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SECURE_GETENV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETENV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SETENV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOLD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOLD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOLD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOLD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOLL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOLL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOUL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOUL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOULL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOULL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYSTEM_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SYSTEM_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SYSTEM_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SYSTEM_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLOCKPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNLOCKPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNLOCKPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNLOCKPT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNSETENV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNSETENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNSETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNSETENV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCTOMB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ECVT], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_ECVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_ECVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_ECVT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FCVT], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_FCVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_FCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_FCVT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GCVT], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_GCVT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_GCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_GCVT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MKTEMP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_MKTEMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_MKTEMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_MKTEMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_PUTENV], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_PUTENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_PUTENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_PUTENV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([calloc-gnu]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[calloc-gnu]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([calloc-gnu]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_CALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_CALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_FUNC_CALLOC_POSIX -m4trace:configure.ac:114: -1- gl_LIBSOURCES([calloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([calloc-posix]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([calloc-posix]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[calloc-posix]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([calloc-posix]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_CALLOC_GNU], [/* Define to 1 when the gnulib module calloc-gnu should be tested. */ +@%:@undef GNULIB_TEST_CALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_CALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_CALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_CANONICALIZE_LGPL -m4trace:configure.ac:114: -1- gl_CANONICALIZE_LGPL_SEPARATE -m4trace:configure.ac:114: -1- gl_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_CALLOC_POSIX], [/* Define to 1 when the gnulib module calloc-posix should be tested. */ +@%:@undef GNULIB_TEST_CALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([LSTAT_FOLLOWS_SLASHED_SYMLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LSTAT_FOLLOWS_SLASHED_SYMLINK$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_canonicalize_file_name], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" canonicalize_file_name ]AS_TR_CPP([HAVE_canonicalize_file_name])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([faccessat], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([faccessat], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([faccessat]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([faccessat], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([faccessat]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([faccessat]) +m4trace:configure.ac:114: -1- AH_OUTPUT([LSTAT_FOLLOWS_SLASHED_SYMLINK], [/* Define to 1 if \'lstat\' dereferences a symlink specified with a trailing + slash. */ +@%:@undef LSTAT_FOLLOWS_SLASHED_SYMLINK]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_CANONICALIZE_FILE_NAME], [/* Define to 1 if you have the \'canonicalize_file_name\' function. */ +@%:@undef HAVE_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FACCESSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FACCESSAT$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FACCESSAT], [/* Define to 1 if you have the `faccessat\' function. */ +@%:@undef HAVE_FACCESSAT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETCWD], [/* Define to 1 if you have the \'getcwd\' function. */ +@%:@undef HAVE_GETCWD]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETCWD$]) -m4trace:configure.ac:114: -1- gl_DOUBLE_SLASH_ROOT +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([DOUBLE_SLASH_IS_DISTINCT_ROOT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^DOUBLE_SLASH_IS_DISTINCT_ROOT$]) -m4trace:configure.ac:114: -1- gl_FUNC_REALPATH_WORKS -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_realpath], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" realpath ]AS_TR_CPP([HAVE_realpath])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_lstat], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" lstat ]AS_TR_CPP([HAVE_lstat])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- GL_NOCRASH +m4trace:configure.ac:114: -1- AH_OUTPUT([DOUBLE_SLASH_IS_DISTINCT_ROOT], [/* Define to 1 if // is a file system root distinct from /. */ +@%:@undef DOUBLE_SLASH_IS_DISTINCT_ROOT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_REALPATH], [/* Define to 1 if you have the \'realpath\' function. */ +@%:@undef HAVE_REALPATH]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LSTAT], [/* Define to 1 if you have the \'lstat\' function. */ +@%:@undef HAVE_LSTAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([FUNC_REALPATH_WORKS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^FUNC_REALPATH_WORKS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([FUNC_REALPATH_WORKS], [/* Define to 1 if realpath() can malloc memory, always gives an absolute path, + and handles leading slashes and a trailing slash correctly. */ +@%:@undef FUNC_REALPATH_WORKS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([FUNC_REALPATH_NEARLY_WORKS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^FUNC_REALPATH_NEARLY_WORKS$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_param_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/param.h ]AS_TR_SH([sys/param.h]) AS_TR_CPP([HAVE_sys/param.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL], [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([FUNC_REALPATH_NEARLY_WORKS], [/* Define to 1 if realpath() can malloc memory, always gives an absolute path, + and handles a trailing slash correctly. */ +@%:@undef FUNC_REALPATH_NEARLY_WORKS]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_PARAM_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_PARAM_H]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL], [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_CANONICALIZE_LGPL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_CANONICALIZE_LGPL_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_CANONICALIZE_LGPL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_CANONICALIZE_LGPL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_CANONICALIZE_LGPL_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_CANONICALIZE_LGPL_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_CANONICALIZE_LGPL_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_CANONICALIZE_LGPL_FALSE]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([canonicalize-lgpl]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_CANONICALIZE_LGPL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_CANONICALIZE_LGPL$]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([canonicalize_file_name]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[canonicalize_file_name]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([canonicalize_file_name]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_CANONICALIZE_LGPL], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module canonicalize-lgpl shall be considered present. */ +@%:@undef GNULIB_CANONICALIZE_LGPL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_CANONICALIZE_FILE_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_CANONICALIZE_FILE_NAME$]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([realpath]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([realpath]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[realpath]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([realpath]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_CANONICALIZE_FILE_NAME], [/* Define to 1 when the gnulib module canonicalize_file_name should be tested. + */ +@%:@undef GNULIB_TEST_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_REALPATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_REALPATH$]) -m4trace:configure.ac:114: -1- AC_C_RESTRICT +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_REALPATH], [/* Define to 1 when the gnulib module realpath should be tested. */ +@%:@undef GNULIB_TEST_REALPATH]) +m4trace:configure.ac:114: -1- AH_OUTPUT([restrict], [/* Define to the equivalent of the C99 \'restrict\' keyword, or to + nothing if this is not supported. Do not define if restrict is + supported only directly. */ +#undef restrict +/* Work around a bug in older versions of Sun C++, which did not + #define __restrict__ or support _Restrict or __restrict__ + even though the corresponding Sun C compiler ended up with + "#define restrict _Restrict" or "#define restrict __restrict__" + in the previous line. This workaround can be removed once + we assume Oracle Developer Studio 12.5 (2016) or later. */ +#if defined __SUNPRO_CC && !defined __RESTRICT && !defined __restrict__ +# define _Restrict +# define __restrict__ +#endif]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([restrict]) m4trace:configure.ac:114: -1- m4_pattern_allow([^restrict$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([restrict]) m4trace:configure.ac:114: -1- m4_pattern_allow([^restrict$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([readlinkat], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([readlinkat], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([readlinkat]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([readlinkat], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([readlinkat]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([readlinkat]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_READLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_READLINKAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([cloexec]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_READLINKAT], [/* Define to 1 if you have the `readlinkat\' function. */ +@%:@undef HAVE_READLINKAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_CLOEXEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_CLOEXEC$]) -m4trace:configure.ac:114: -1- gl_FUNC_CLOSE -m4trace:configure.ac:114: -1- gl_UNISTD_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_CLOEXEC], [/* Define to 1 when the gnulib module cloexec should be tested. */ +@%:@undef GNULIB_TEST_CLOEXEC]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_CHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_CHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_CHOWN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_COPY_FILE_RANGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_COPY_FILE_RANGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_COPY_FILE_RANGE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DUP3]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DUP3]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DUP3$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_EUIDACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_EUIDACCESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_EUIDACCESS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_EXECVPE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FACCESSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FACCESSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FACCESSAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FCHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FCHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FCHDIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FCHOWNAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FCHOWNAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FCHOWNAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FDATASYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FDATASYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FDATASYNC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FSYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FSYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FSYNC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FTRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FTRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FTRUNCATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETDTABLESIZE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETENTROPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETENTROPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETENTROPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETGROUPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETGROUPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETGROUPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETHOSTNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETLOGIN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETLOGIN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETLOGIN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETPAGESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETPAGESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETPAGESIZE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETPASS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETPASS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETPASS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GROUP_MEMBER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GROUP_MEMBER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GROUP_MEMBER$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LCHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LCHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LCHOWN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PIPE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PIPE2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PIPE2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PIPE2$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PWRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PWRITE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_READLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_READLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_READLINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_READLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_READLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_READLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SETHOSTNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYMLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYMLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYMLINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYMLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYMLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYMLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UNLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UNLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_USLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_USLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_USLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_ENVIRON]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_ENVIRON]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_ENVIRON$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_EXECVPE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FCHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FCHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FCHDIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FDATASYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FDATASYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FDATASYNC$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETDOMAINNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETDOMAINNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETDOMAINNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETLOGIN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETLOGIN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETLOGIN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETLOGIN_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETLOGIN_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETLOGIN_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETPAGESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETPAGESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETPAGESIZE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETUSERSHELL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETUSERSHELL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETUSERSHELL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_SETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_SETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_SETHOSTNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_TRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_TRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_TRUNCATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_TTYNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_TTYNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_TTYNAME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_OS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_OS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_OS_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_PARAM_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_PARAM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_PARAM_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ACCESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ACCESS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CHOWN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CLOSE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_COPY_FILE_RANGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_COPY_FILE_RANGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_COPY_FILE_RANGE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_DUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_DUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_DUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_DUP2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_DUP2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_DUP2$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_DUP3]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_DUP3]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_DUP3$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECLE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECLP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECLP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECLP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECVE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECVP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECVP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECVP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_EXECVPE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FACCESSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FACCESSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FACCESSAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FCHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FCHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FCHDIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FCHOWNAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FCHOWNAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FCHOWNAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FDATASYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FDATASYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FDATASYNC$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FTRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FTRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FTRUNCATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETCWD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETDOMAINNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETDOMAINNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETDOMAINNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETDTABLESIZE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETENTROPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETENTROPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETENTROPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETLOGIN_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETLOGIN_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETLOGIN_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETGROUPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETGROUPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETGROUPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETPAGESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETPAGESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETPAGESIZE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETPASS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETPASS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETPASS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETPASS_FOR_GETPASS_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETPASS_FOR_GETPASS_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETPASS_FOR_GETPASS_GNU$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISATTY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISATTY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISATTY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LCHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LCHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LCHOWN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LSEEK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LSEEK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PIPE2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PIPE2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PIPE2$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PWRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PWRITE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_READ]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_READ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_READ$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_READLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_READLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_READLINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_READLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_READLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_READLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RMDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RMDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RMDIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SETHOSTNAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SYMLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SYMLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SYMLINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SYMLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SYMLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SYMLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TRUNCATE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TTYNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TTYNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TTYNAME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_UNLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_UNLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_UNLINK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_UNLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_UNLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_UNLINKAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_USLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_USLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_USLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WRITE$]) +m4trace:configure.ac:114: -1- AC_SUBST([UNISTD_H_HAVE_SYS_RANDOM_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UNISTD_H_HAVE_SYS_RANDOM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UNISTD_H_HAVE_SYS_RANDOM_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([UNISTD_H_HAVE_WINSOCK2_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UNISTD_H_HAVE_WINSOCK2_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UNISTD_H_HAVE_WINSOCK2_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS$]) -m4trace:configure.ac:114: -1- gl_MSVC_INVAL -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func__set_invalid_parameter_handler], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" _set_invalid_parameter_handler ]AS_TR_CPP([HAVE__set_invalid_parameter_handler])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE__SET_INVALID_PARAMETER_HANDLER], [/* Define to 1 if you have the \'_set_invalid_parameter_handler\' function. */ +@%:@undef HAVE__SET_INVALID_PARAMETER_HANDLER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MSVC_INVALID_PARAMETER_HANDLER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MSVC_INVALID_PARAMETER_HANDLER$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MSVC_INVALID_PARAMETER_HANDLER], [/* Define to 1 on MSVC platforms that have the "invalid parameter handler" + concept. */ +@%:@undef HAVE_MSVC_INVALID_PARAMETER_HANDLER]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MSVC_INVALID_PARAMETER_HANDLER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MSVC_INVALID_PARAMETER_HANDLER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MSVC_INVALID_PARAMETER_HANDLER$]) -m4trace:configure.ac:114: -1- gl_PREREQ_SYS_H_WINSOCK2 -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_socket_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/socket.h ]AS_TR_SH([sys/socket.h]) AS_TR_CPP([HAVE_sys/socket.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_SOCKET_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_SOCKET_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WINSOCK2_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WINSOCK2_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WINSOCK2_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINSOCK2_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WINSOCK2_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WINSOCK2_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINSOCK2_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_CLOSE], [test $REPLACE_CLOSE = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_CLOSE], [test $REPLACE_CLOSE = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_CLOSE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_CLOSE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_CLOSE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_CLOSE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_CLOSE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_CLOSE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_CLOSE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_CLOSE_FALSE]) -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([close]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ACCESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ACCESS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CHDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CHOWN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CLOSE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_COPY_FILE_RANGE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_COPY_FILE_RANGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_COPY_FILE_RANGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_COPY_FILE_RANGE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_DUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_DUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_DUP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP2]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_DUP2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_DUP2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_DUP2$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUP3]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_DUP3]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_DUP3]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_DUP3$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ENVIRON]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ENVIRON]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ENVIRON]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ENVIRON$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EUIDACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EUIDACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EUIDACCESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EUIDACCESS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECLE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECLP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECLP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECLP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECLP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECVE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECVP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECVP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECVP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXECVPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FACCESSAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FACCESSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FACCESSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FACCESSAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FCHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FCHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FCHDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHOWNAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FCHOWNAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FCHOWNAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FCHOWNAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FDATASYNC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FDATASYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FDATASYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FDATASYNC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSYNC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSYNC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSYNC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSYNC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FTRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FTRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FTRUNCATE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETCWD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDOMAINNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETDOMAINNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETDOMAINNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETDOMAINNAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETDTABLESIZE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETENTROPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETENTROPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETENTROPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETENTROPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETGROUPS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETGROUPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETGROUPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETGROUPS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETHOSTNAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOGIN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETLOGIN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETLOGIN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETLOGIN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLOGIN_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETLOGIN_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETLOGIN_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETLOGIN_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETOPT_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETOPT_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETOPT_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETOPT_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPAGESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETPAGESIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETPAGESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETPAGESIZE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPASS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETPASS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETPASS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETPASS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETPASS_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETPASS_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETPASS_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETPASS_GNU$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETUSERSHELL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETUSERSHELL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETUSERSHELL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETUSERSHELL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GROUP_MEMBER]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GROUP_MEMBER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GROUP_MEMBER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GROUP_MEMBER$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISATTY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISATTY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISATTY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISATTY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LCHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LCHOWN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LCHOWN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LCHOWN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LINK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LINK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LINKAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LSEEK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LSEEK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PIPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PIPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PIPE2]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PIPE2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PIPE2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PIPE2$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PREAD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PREAD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PWRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PWRITE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READ]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_READ]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_READ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_READ$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READLINK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_READLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_READLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_READLINK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_READLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_READLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_READLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_READLINKAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RMDIR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RMDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RMDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RMDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SETHOSTNAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SETHOSTNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SETHOSTNAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SLEEP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYMLINK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SYMLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SYMLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SYMLINK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SYMLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SYMLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SYMLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SYMLINKAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TRUNCATE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TRUNCATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TRUNCATE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TTYNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TTYNAME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TTYNAME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TTYNAME_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNISTD_H_GETOPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNISTD_H_GETOPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNISTD_H_GETOPT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNISTD_H_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNISTD_H_NONBLOCKING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNISTD_H_NONBLOCKING$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNISTD_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNISTD_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNISTD_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLINK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNLINK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNLINKAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNLINKAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNLINKAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_USLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_USLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_USLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_USLEEP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WRITE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WRITE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ACCESS], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_ACCESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_ACCESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_ACCESS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CHDIR], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_CHDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_CHDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_CHDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CLOSE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_CLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_CLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_CLOSE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_DUP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_DUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_DUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_DUP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_DUP2], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_DUP2]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_DUP2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_DUP2$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECL], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECLE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECLP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECLP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECLP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECLP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECV], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECVE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECVP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECVP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECVP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_EXECVPE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_EXECVPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETCWD], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_GETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_GETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_GETCWD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETPID], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_GETPID]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_GETPID]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_GETPID$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_ISATTY], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_ISATTY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_ISATTY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_ISATTY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_LSEEK], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_LSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_LSEEK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_LSEEK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_READ], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_READ]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_READ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_READ$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_RMDIR], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_RMDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_RMDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_RMDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_SWAB], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_SWAB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_SWAB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_SWAB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_UNLINK], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_UNLINK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_UNLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_UNLINK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_WRITE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_WRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_WRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_WRITE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([close]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[close]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([close]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_CLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_CLOSE$]) -m4trace:configure.ac:114: -1- gl_DOUBLE_SLASH_ROOT +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_CLOSE], [/* Define to 1 when the gnulib module close should be tested. */ +@%:@undef GNULIB_TEST_CLOSE]) +m4trace:configure.ac:114: -1- AC_CONFIG_FILES([csharpcomp.sh:../build-aux/csharpcomp.sh.in]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([DOUBLE_SLASH_IS_DISTINCT_ROOT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^DOUBLE_SLASH_IS_DISTINCT_ROOT$]) -m4trace:configure.ac:114: -1- gl_FUNC_DUP2 -m4trace:configure.ac:114: -1- GL_MDA_DEFINES -m4trace:configure.ac:114: -1- _GL_MDA_DEFINES +m4trace:configure.ac:114: -1- AH_OUTPUT([DOUBLE_SLASH_IS_DISTINCT_ROOT], [/* Define to 1 if // is a file system root distinct from /. */ +@%:@undef DOUBLE_SLASH_IS_DISTINCT_ROOT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SETDTABLESIZE], [/* Define to 1 if you have the \'setdtablesize\' function. */ +@%:@undef HAVE_SETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SETDTABLESIZE$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_DUP2], [test $REPLACE_DUP2 = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_DUP2], [test $REPLACE_DUP2 = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_DUP2_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_DUP2_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_DUP2_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_DUP2_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_DUP2_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_DUP2_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_DUP2_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_DUP2_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_DUP2], [ - gl_PREREQ_DUP2 - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_DUP2 -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([dup2]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([dup2]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[dup2]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([dup2]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_DUP2]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_DUP2]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_DUP2]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_DUP2$]) -m4trace:configure.ac:114: -1- gl_ENVIRON -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_unistd_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" unistd.h ]AS_TR_SH([unistd.h]) AS_TR_CPP([HAVE_unistd.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gt_CHECK_VAR_DECL([#if HAVE_UNISTD_H - #include - #endif - /* mingw, BeOS, Haiku declare environ in , not in . */ - #include - ], [environ]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_DUP2], [/* Define to 1 when the gnulib module dup2 should be tested. */ +@%:@undef GNULIB_TEST_DUP2]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ENVIRON_DECL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ENVIRON_DECL$]) -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([environ]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([environ]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[environ]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([environ]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ENVIRON_DECL], [/* Define if you have the declaration of environ. */ +@%:@undef HAVE_ENVIRON_DECL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_ENVIRON]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_ENVIRON$]) -m4trace:configure.ac:114: -1- gl_HEADER_ERRNO_H -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([errno.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([errno.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([errno.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_ENVIRON], [/* Define to 1 when the gnulib module environ should be tested. */ +@%:@undef GNULIB_TEST_ENVIRON]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_ERRNO_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_ERRNO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_ERRNO_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_ERRNO_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_ERRNO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_ERRNO_H$]) -m4trace:configure.ac:114: -1- gl_REPLACE_ERRNO_VALUE([EMULTIHOP]) +m4trace:configure.ac:114: -1- AC_SUBST([EMULTIHOP_HIDDEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([EMULTIHOP_HIDDEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^EMULTIHOP_HIDDEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([EMULTIHOP_VALUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([EMULTIHOP_VALUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^EMULTIHOP_VALUE$]) -m4trace:configure.ac:114: -1- gl_REPLACE_ERRNO_VALUE([ENOLINK]) +m4trace:configure.ac:114: -1- AC_SUBST([ENOLINK_HIDDEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ENOLINK_HIDDEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ENOLINK_HIDDEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([ENOLINK_VALUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ENOLINK_VALUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ENOLINK_VALUE$]) -m4trace:configure.ac:114: -1- gl_REPLACE_ERRNO_VALUE([EOVERFLOW]) +m4trace:configure.ac:114: -1- AC_SUBST([EOVERFLOW_HIDDEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([EOVERFLOW_HIDDEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^EOVERFLOW_HIDDEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([EOVERFLOW_VALUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([EOVERFLOW_VALUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^EOVERFLOW_VALUE$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([errno.h]) +m4trace:configure.ac:114: -1- AC_SUBST([ERRNO_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ERRNO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ERRNO_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_ERRNO_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_ERRNO_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ERRNO_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ERRNO_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ERRNO_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ERRNO_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ERRNO_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ERRNO_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ERRNO_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ERRNO_H_FALSE]) -m4trace:configure.ac:114: -1- gl_ERROR_H -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([error.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([error.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_error_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" error.h ]AS_TR_SH([error.h]) AS_TR_CPP([HAVE_error.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([error.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ERROR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_ERROR_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_ERROR_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_ERROR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_ERROR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_ERROR_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_ERROR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_ERROR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ERROR_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ERROR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ERROR_H$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([error], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([error], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([error]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([error], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([error]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([error]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ERROR$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ERROR], [/* Define to 1 if you have the `error\' function. */ +@%:@undef HAVE_ERROR]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ERROR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ERROR_AT_LINE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ERROR_AT_LINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ERROR_AT_LINE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ERROR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ERROR_AT_LINE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ERROR_AT_LINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ERROR_AT_LINE$]) -m4trace:configure.ac:114: -1- gl_ERROR -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ERROR], [test $COMPILE_ERROR_C = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ERROR], [test $COMPILE_ERROR_C = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ERROR_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ERROR_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ERROR_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ERROR_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ERROR_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ERROR_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ERROR_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ERROR_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_ERROR], [ - gl_PREREQ_ERROR - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_ERROR -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_strerror_r], [_AC_CHECK_DECLS([strerror_r])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_ERROR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_STRERROR_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRERROR_R$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_STRERROR_R], [/* Define to 1 if you have the declaration of \'strerror_r\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRERROR_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRERROR_R$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRERROR_R], [/* Define if you have \'strerror_r\'. */ +@%:@undef HAVE_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([STRERROR_R_CHAR_P]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STRERROR_R_CHAR_P$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([STRERROR_R_CHAR_P], [/* Define to 1 if strerror_r returns char *. */ +@%:@undef STRERROR_R_CHAR_P]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_ERROR]) m4trace:configure.ac:114: -1- AM_XGETTEXT_OPTION([--flag=error:3:c-format]) -m4trace:configure.ac:114: -1- AM_XGETTEXT_OPTION_INIT m4trace:configure.ac:114: -1- AM_XGETTEXT_OPTION([--flag=error_at_line:5:c-format]) -m4trace:configure.ac:114: -1- gl_ERROR_H -m4trace:configure.ac:114: -1- gl_EXTERN_INLINE +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE___HEADER_INLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE___HEADER_INLINE$]) -m4trace:configure.ac:114: -1- gl_FUNC_FCNTL -m4trace:configure.ac:114: -1- gl_FCNTL_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE___HEADER_INLINE], [/* Define to 1 if ctype.h defines __header_inline. */ +@%:@undef HAVE___HEADER_INLINE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE___HEADER_INLINE_1], [/* Please see the Gnulib manual for how to use these macros. + + Suppress extern inline with HP-UX cc, as it appears to be broken; see + . + + Suppress extern inline with Sun C in standards-conformance mode, as it + mishandles inline functions that call each other. E.g., for \'inline void f + (void) { } inline void g (void) { f (); }\', c99 incorrectly complains + \'reference to static identifier "f" in extern inline function\'. + This bug was observed with Oracle Developer Studio 12.6 + (Sun C 5.15 SunOS_sparc 2017/05/30). + + Suppress extern inline (with or without __attribute__ ((__gnu_inline__))) + on configurations that mistakenly use \'static inline\' to implement + functions or macros in standard C headers like . For example, + if isdigit is mistakenly implemented via a static inline function, + a program containing an extern inline function that calls isdigit + may not work since the C standard prohibits extern inline functions + from calling static functions (ISO C 99 section 6.7.4.(3). + This bug is known to occur on: + + OS X 10.8 and earlier; see: + https://lists.gnu.org/r/bug-gnulib/2012-12/msg00023.html + + DragonFly; see + http://muscles.dragonflybsd.org/bulk/clang-master-potential/20141111_102002/logs/ah-tty-0.3.12.log + + FreeBSD; see: + https://lists.gnu.org/r/bug-gnulib/2014-07/msg00104.html + + OS X 10.9 has a macro __header_inline indicating the bug is fixed for C and + for clang but remains for g++; see . + Assume DragonFly and FreeBSD will be similar. + + GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99 + inline semantics, unless -fgnu89-inline is used. It defines a macro + __GNUC_STDC_INLINE__ to indicate this situation or a macro + __GNUC_GNU_INLINE__ to indicate the opposite situation. + GCC 4.2 with -std=c99 or -std=gnu99 implements the GNU C inline + semantics but warns, unless -fgnu89-inline is used: + warning: C99 inline functions are not supported; using GNU89 + warning: to disable this warning use -fgnu89-inline or the gnu_inline function attribute + It defines a macro __GNUC_GNU_INLINE__ to indicate this situation. + */ +#if (((defined __APPLE__ && defined __MACH__) \\ + || defined __DragonFly__ || defined __FreeBSD__) \\ + && (defined HAVE___HEADER_INLINE \\ + ? (defined __cplusplus && defined __GNUC_STDC_INLINE__ \\ + && ! defined __clang__) \\ + : ((! defined _DONT_USE_CTYPE_INLINE_ \\ + && (defined __GNUC__ || defined __cplusplus)) \\ + || (defined _FORTIFY_SOURCE && 0 < _FORTIFY_SOURCE \\ + && defined __GNUC__ && ! defined __cplusplus)))) +# define _GL_EXTERN_INLINE_STDHEADER_BUG +#endif +#if ((__GNUC__ \\ + ? (defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__ \\ + && !defined __PCC__) \\ + : (199901L <= __STDC_VERSION__ \\ + && !defined __HP_cc \\ + && !defined __PGI \\ + && !(defined __SUNPRO_C && __STDC__))) \\ + && !defined _GL_EXTERN_INLINE_STDHEADER_BUG) +# define _GL_INLINE inline +# define _GL_EXTERN_INLINE extern inline +# define _GL_EXTERN_INLINE_IN_USE +#elif (2 < __GNUC__ + (7 <= __GNUC_MINOR__) && !defined __STRICT_ANSI__ \\ + && !defined __PCC__ \\ + && !defined _GL_EXTERN_INLINE_STDHEADER_BUG) +# if defined __GNUC_GNU_INLINE__ && __GNUC_GNU_INLINE__ + /* __gnu_inline__ suppresses a GCC 4.2 diagnostic. */ +# define _GL_INLINE extern inline __attribute__ ((__gnu_inline__)) +# else +# define _GL_INLINE extern inline +# endif +# define _GL_EXTERN_INLINE extern +# define _GL_EXTERN_INLINE_IN_USE +#else +# define _GL_INLINE _GL_UNUSED static +# define _GL_EXTERN_INLINE _GL_UNUSED static +#endif + +/* In GCC 4.6 (inclusive) to 5.1 (exclusive), + suppress bogus "no previous prototype for \'FOO\'" + and "no previous declaration for \'FOO\'" diagnostics, + when FOO is an inline function in the header; see + and + . */ +#if __GNUC__ == 4 && 6 <= __GNUC_MINOR__ +# if defined __GNUC_STDC_INLINE__ && __GNUC_STDC_INLINE__ +# define _GL_INLINE_HEADER_CONST_PRAGMA +# else +# define _GL_INLINE_HEADER_CONST_PRAGMA \\ + _Pragma ("GCC diagnostic ignored \\"-Wsuggest-attribute=const\\"") +# endif +# define _GL_INLINE_HEADER_BEGIN \\ + _Pragma ("GCC diagnostic push") \\ + _Pragma ("GCC diagnostic ignored \\"-Wmissing-prototypes\\"") \\ + _Pragma ("GCC diagnostic ignored \\"-Wmissing-declarations\\"") \\ + _GL_INLINE_HEADER_CONST_PRAGMA +# define _GL_INLINE_HEADER_END \\ + _Pragma ("GCC diagnostic pop") +#else +# define _GL_INLINE_HEADER_BEGIN +# define _GL_INLINE_HEADER_END +#endif]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FCNTL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FCNTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FCNTL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_OPENAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_OPENAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_OPENAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CREAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CREAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CREAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FCNTL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FCNTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FCNTL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_OPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_OPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_OPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_OPENAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_OPENAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_OPENAT$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_fcntl], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" fcntl ]AS_TR_CPP([HAVE_fcntl])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_REPLACE_FCNTL -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_fcntl], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" fcntl ]AS_TR_CPP([HAVE_fcntl])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- GL_MDA_DEFINES -m4trace:configure.ac:114: -1- gl_REPLACE_FCNTL -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_fcntl], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" fcntl ]AS_TR_CPP([HAVE_fcntl])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FCNTL], [/* Define to 1 if you have the \'fcntl\' function. */ +@%:@undef HAVE_FCNTL]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FCNTL], [/* Define to 1 if you have the \'fcntl\' function. */ +@%:@undef HAVE_FCNTL]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FCNTL], [/* Define to 1 if you have the \'fcntl\' function. */ +@%:@undef HAVE_FCNTL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([FCNTL_DUPFD_BUGGY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^FCNTL_DUPFD_BUGGY$]) -m4trace:configure.ac:114: -1- gl_REPLACE_FCNTL -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_fcntl], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" fcntl ]AS_TR_CPP([HAVE_fcntl])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_FCNTL], [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([FCNTL_DUPFD_BUGGY], [/* Define this to 1 if F_DUPFD behavior does not match POSIX */ +@%:@undef FCNTL_DUPFD_BUGGY]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FCNTL], [/* Define to 1 if you have the \'fcntl\' function. */ +@%:@undef HAVE_FCNTL]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_FCNTL], [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FCNTL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FCNTL_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FCNTL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FCNTL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FCNTL_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FCNTL_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FCNTL_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FCNTL_FALSE]) -m4trace:configure.ac:114: -1- gl_FCNTL_MODULE_INDICATOR([fcntl]) -m4trace:configure.ac:114: -1- gl_FCNTL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CREAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CREAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CREAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CREAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCNTL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FCNTL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FCNTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FCNTL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_NONBLOCKING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_NONBLOCKING$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OPEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_OPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_OPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_OPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OPENAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_OPENAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_OPENAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_OPENAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CREAT], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_CREAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_CREAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_CREAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_OPEN], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_OPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_OPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_OPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fcntl]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fcntl]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fcntl]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FCNTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FCNTL$]) -m4trace:configure.ac:114: -1- gl_FCNTL_H -m4trace:configure.ac:114: -1- gl_FCNTL_O_FLAGS -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_unistd_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" unistd.h ]AS_TR_SH([unistd.h]) AS_TR_CPP([HAVE_unistd.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_symlink], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" symlink ]AS_TR_CPP([HAVE_symlink])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- GL_MDA_DEFINES +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FCNTL], [/* Define to 1 when the gnulib module fcntl should be tested. */ +@%:@undef GNULIB_TEST_FCNTL]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYMLINK], [/* Define to 1 if you have the \'symlink\' function. */ +@%:@undef HAVE_SYMLINK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WORKING_O_NOATIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WORKING_O_NOATIME$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WORKING_O_NOATIME], [/* Define to 1 if O_NOATIME works. */ +@%:@undef HAVE_WORKING_O_NOATIME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WORKING_O_NOFOLLOW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WORKING_O_NOFOLLOW$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([fcntl.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([fcntl.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([fcntl.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WORKING_O_NOFOLLOW], [/* Define to 1 if O_NOFOLLOW works. */ +@%:@undef HAVE_WORKING_O_NOFOLLOW]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_FCNTL_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_FCNTL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_FCNTL_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_FCNTL_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_FCNTL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_FCNTL_H$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([pid_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^pid_t$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([pid_t], [/* Define as a signed integer type capable of holding a process identifier. */ +@%:@undef pid_t]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([mode_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^mode_t$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [fcntl openat]) -m4trace:configure.ac:114: -1- gl_FCNTL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- AC_C_FLEXIBLE_ARRAY_MEMBER +m4trace:configure.ac:114: -1- AH_OUTPUT([mode_t], [/* Define to \'int\' if does not define. */ +@%:@undef mode_t]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([FLEXIBLE_ARRAY_MEMBER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^FLEXIBLE_ARRAY_MEMBER$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([FLEXIBLE_ARRAY_MEMBER], [/* Define to nothing if C supports flexible array members, and to 1 if it does + not. That way, with a declaration like \'struct s { int n; short + d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };\', the struct hack can be used with pre-C99 + compilers. Use \'FLEXSIZEOF (struct s, d, N * sizeof (short))\' to calculate + the size in bytes of such a struct containing an N-element array. */ +@%:@undef FLEXIBLE_ARRAY_MEMBER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([FLEXIBLE_ARRAY_MEMBER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^FLEXIBLE_ARRAY_MEMBER$]) -m4trace:configure.ac:114: -1- gl_FUNC_FREE +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FREE_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FREE_POSIX$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_FREE], [test $REPLACE_FREE = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FREE_POSIX], [/* Define if the \'free\' function is guaranteed to preserve errno. */ +@%:@undef HAVE_FREE_POSIX]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_FREE], [test $REPLACE_FREE = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FREE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FREE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FREE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FREE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FREE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FREE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FREE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FREE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_FREE], [ - gl_PREREQ_FREE - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_FREE -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([free-posix]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([free-posix]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[free-posix]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([free-posix]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_FREE]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_FREE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FREE_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FREE_POSIX$]) -m4trace:configure.ac:114: -1- gl_FUNC_FSTAT -m4trace:configure.ac:114: -1- gl_SYS_STAT_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FREE_POSIX], [/* Define to 1 when the gnulib module free-posix should be tested. */ +@%:@undef GNULIB_TEST_FREE_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FCHMODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FCHMODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FCHMODAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FSTATAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FSTATAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FSTATAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FUTIMENS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FUTIMENS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FUTIMENS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETUMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETUMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETUMASK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LCHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LCHMOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LCHMOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LSTAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKDIRAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKDIRAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKDIRAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKFIFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKFIFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKFIFO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKFIFOAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKFIFOAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKFIFOAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKNOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKNOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKNOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MKNODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MKNODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MKNODAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UTIMENSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UTIMENSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UTIMENSAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CHMOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CHMOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FCHMODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FCHMODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FCHMODAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FSTAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FSTATAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FSTATAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FSTATAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FUTIMENS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FUTIMENS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FUTIMENS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LSTAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKDIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKFIFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKFIFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKFIFO$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKFIFOAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKFIFOAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKFIFOAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKNOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKNOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKNOD$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKNODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKNODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKNODAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_UTIMENSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_UTIMENSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_UTIMENSAT$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_FSTAT], [test $REPLACE_FSTAT = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_FSTAT], [test $REPLACE_FSTAT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FSTAT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FSTAT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FSTAT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_FSTAT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_FSTAT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_FSTAT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FSTAT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_FSTAT_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_FSTAT], [ - case "$host_os" in - mingw* | windows*) - AC_LIBOBJ([stat-w32]) - ;; - esac - gl_PREREQ_FSTAT - ]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([stat-w32.c]) -m4trace:configure.ac:114: -1- gl_PREREQ_FSTAT -m4trace:configure.ac:114: -1- gl_SYS_STAT_H +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_FSTAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([STAT_MACROS_BROKEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STAT_MACROS_BROKEN$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([sys/stat.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([sys/stat.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_stat_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/stat.h ]AS_TR_SH([sys/stat.h]) AS_TR_CPP([HAVE_sys/stat.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([sys/stat.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([STAT_MACROS_BROKEN], [/* Define to 1 if the \'S_IS*\' macros in do not work properly. */ +@%:@undef STAT_MACROS_BROKEN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_STAT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_STAT_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_SYS_STAT_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_SYS_STAT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_SYS_STAT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_SYS_STAT_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_SYS_STAT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_SYS_STAT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([WINDOWS_STAT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WINDOWS_STAT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WINDOWS_STAT_TIMESPEC$]) -m4trace:configure.ac:114: -1- gl_LARGEFILE +m4trace:configure.ac:114: -1- AC_SUBST([WINDOWS_64_BIT_ST_SIZE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WINDOWS_64_BIT_ST_SIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WINDOWS_64_BIT_ST_SIZE$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([nlink_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^nlink_t$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [chmod fchmodat fstat fstatat futimens getumask lchmod lstat - mkdirat mkfifo mkfifoat mknod mknodat stat utimensat]) -m4trace:configure.ac:114: -1- gl_PREREQ_STAT_W32 +m4trace:configure.ac:114: -1- AH_OUTPUT([nlink_t], [/* Define to the type of st_nlink in struct stat, or a supertype. */ +@%:@undef nlink_t]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SDKDDKVER_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SDKDDKVER_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SDKDDKVER_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SDKDDKVER_H$]) -m4trace:configure.ac:114: -1- gl_SYS_STAT_MODULE_INDICATOR([fstat]) -m4trace:configure.ac:114: -1- gl_SYS_STAT_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CHMOD]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_FSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CHMOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CHMOD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCHMODAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FCHMODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FCHMODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FCHMODAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSTAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSTATAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSTATAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSTATAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSTATAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FUTIMENS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FUTIMENS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FUTIMENS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FUTIMENS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETUMASK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETUMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETUMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETUMASK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LCHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LCHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LCHMOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LCHMOD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LSTAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LSTAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDIR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKDIRAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKDIRAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKDIRAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKDIRAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKFIFO]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKFIFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKFIFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKFIFO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKFIFOAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKFIFOAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKFIFOAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKFIFOAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKNOD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKNOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKNOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKNOD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKNODAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKNODAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKNODAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKNODAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UTIMENSAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UTIMENSAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UTIMENSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UTIMENSAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OVERRIDES_STRUCT_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_OVERRIDES_STRUCT_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_OVERRIDES_STRUCT_STAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_OVERRIDES_STRUCT_STAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_CHMOD], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_CHMOD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_CHMOD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_CHMOD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MKDIR], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_MKDIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_MKDIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_MKDIR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_UMASK], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_UMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_UMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_UMASK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fstat]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fstat]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fstat]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FSTAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FSTAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([fwriteerror]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FSTAT], [/* Define to 1 when the gnulib module fstat should be tested. */ +@%:@undef GNULIB_TEST_FSTAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_FWRITEERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_FWRITEERROR$]) -m4trace:configure.ac:114: -1- gl_FUNC_GETDTABLESIZE -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_getdtablesize], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" getdtablesize ]AS_TR_CPP([HAVE_getdtablesize])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_getdtablesize], [_AC_CHECK_DECLS([getdtablesize])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_FWRITEERROR], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module fwriteerror shall be considered present. */ +@%:@undef GNULIB_FWRITEERROR]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETDTABLESIZE], [/* Define to 1 if you have the \'getdtablesize\' function. */ +@%:@undef HAVE_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_GETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETDTABLESIZE$]) -m4trace:configure.ac:114: -1- GL_MDA_DEFINES -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_GETDTABLESIZE], [test $HAVE_GETDTABLESIZE = 0 || test $REPLACE_GETDTABLESIZE = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_GETDTABLESIZE], [/* Define to 1 if you have the declaration of \'getdtablesize\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_GETDTABLESIZE]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_GETDTABLESIZE], [test $HAVE_GETDTABLESIZE = 0 || test $REPLACE_GETDTABLESIZE = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETDTABLESIZE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETDTABLESIZE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETDTABLESIZE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETDTABLESIZE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETDTABLESIZE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETDTABLESIZE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETDTABLESIZE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETDTABLESIZE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_GETDTABLESIZE], [ - gl_PREREQ_GETDTABLESIZE - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_GETDTABLESIZE -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([getdtablesize]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([getdtablesize]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[getdtablesize]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([getdtablesize]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_GETDTABLESIZE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_GETDTABLESIZE$]) -m4trace:configure.ac:114: -1- gl_FUNC_GETOPT_GNU -m4trace:configure.ac:114: -1- gl_FUNC_GETOPT_POSIX -m4trace:configure.ac:114: -1- gl_GETOPT_CHECK_HEADERS -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([getopt.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([getopt.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_getopt_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" getopt.h ]AS_TR_SH([getopt.h]) AS_TR_CPP([HAVE_getopt.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([getopt.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_GETDTABLESIZE], [/* Define to 1 when the gnulib module getdtablesize should be tested. */ +@%:@undef GNULIB_TEST_GETDTABLESIZE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETOPT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_GETOPT_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_GETOPT_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_GETOPT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_GETOPT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_GETOPT_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_GETOPT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_GETOPT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_GETOPT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_GETOPT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETOPT_H$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETOPT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_GETOPT_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETOPT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETOPT_H$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETOPT_LONG_ONLY], [/* Define to 1 if you have the \'getopt_long_only\' function. */ +@%:@undef HAVE_GETOPT_LONG_ONLY]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETOPT_LONG_ONLY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETOPT_LONG_ONLY$]) -m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:2979: AC_RUN_IFELSE is expanded from... -lib/m4sugar/m4sh.m4:690: _AS_IF_ELSE is expanded from... -lib/m4sugar/m4sh.m4:697: AS_IF is expanded from... -./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from... -./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from... +m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:3037: AC_RUN_IFELSE is expanded from... +lib/m4sugar/m4sh.m4:689: _AS_IF_ELSE is expanded from... +lib/m4sugar/m4sh.m4:696: AS_IF is expanded from... +./lib/autoconf/general.m4:2305: AC_CACHE_VAL is expanded from... +./lib/autoconf/general.m4:2326: AC_CACHE_CHECK is expanded from... gnulib-m4/getopt.m4:50: gl_GETOPT_CHECK_HEADERS is expanded from... gnulib-m4/getopt.m4:8: gl_FUNC_GETOPT_POSIX is expanded from... gnulib-m4/gnulib-comp.m4:253: gl_INIT is expanded from... configure.ac:114: the top level]) -m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:2979: AC_RUN_IFELSE is expanded from... -lib/m4sugar/m4sh.m4:690: _AS_IF_ELSE is expanded from... -lib/m4sugar/m4sh.m4:697: AS_IF is expanded from... -./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from... -./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from... +m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:3037: AC_RUN_IFELSE is expanded from... +lib/m4sugar/m4sh.m4:689: _AS_IF_ELSE is expanded from... +lib/m4sugar/m4sh.m4:696: AS_IF is expanded from... +./lib/autoconf/general.m4:2305: AC_CACHE_VAL is expanded from... +./lib/autoconf/general.m4:2326: AC_CACHE_CHECK is expanded from... gnulib-m4/getopt.m4:50: gl_GETOPT_CHECK_HEADERS is expanded from... gnulib-m4/getopt.m4:8: gl_FUNC_GETOPT_POSIX is expanded from... gnulib-m4/gnulib-comp.m4:253: gl_INIT is expanded from... configure.ac:114: the top level]) -m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:2979: AC_RUN_IFELSE is expanded from... -lib/m4sugar/m4sh.m4:690: _AS_IF_ELSE is expanded from... -lib/m4sugar/m4sh.m4:697: AS_IF is expanded from... -./lib/autoconf/general.m4:2249: AC_CACHE_VAL is expanded from... -./lib/autoconf/general.m4:2270: AC_CACHE_CHECK is expanded from... +m4trace:configure.ac:114: -1- _m4_warn([cross], [AC_RUN_IFELSE called without default to allow cross compiling], [./lib/autoconf/general.m4:3037: AC_RUN_IFELSE is expanded from... +lib/m4sugar/m4sh.m4:689: _AS_IF_ELSE is expanded from... +lib/m4sugar/m4sh.m4:696: AS_IF is expanded from... +./lib/autoconf/general.m4:2305: AC_CACHE_VAL is expanded from... +./lib/autoconf/general.m4:2326: AC_CACHE_CHECK is expanded from... gnulib-m4/getopt.m4:50: gl_GETOPT_CHECK_HEADERS is expanded from... gnulib-m4/getopt.m4:8: gl_FUNC_GETOPT_POSIX is expanded from... gnulib-m4/gnulib-comp.m4:253: gl_INIT is expanded from... configure.ac:114: the top level]) -m4trace:configure.ac:114: -1- GL_NOCRASH -m4trace:configure.ac:114: -1- gl_GETOPT_SUBSTITUTE_HEADER -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_cdefs_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/cdefs.h ]AS_TR_SH([sys/cdefs.h]) AS_TR_CPP([HAVE_sys/cdefs.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_CDEFS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_CDEFS_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_CDEFS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_CDEFS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_CDEFS_H$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([__GETOPT_PREFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^__GETOPT_PREFIX$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([getopt.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([__GETOPT_PREFIX], [/* Define to rpl_ if the getopt replacement functions and variables should be + used. */ +@%:@undef __GETOPT_PREFIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GETOPT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GETOPT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GETOPT_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_GETOPT_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_GETOPT_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_GETOPT_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_GETOPT_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_GETOPT_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_GETOPT_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_GETOPT_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_GETOPT_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_GETOPT_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_GETOPT_H_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([getopt-cdefs.h]) +m4trace:configure.ac:114: -1- AC_SUBST([GETOPT_CDEFS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GETOPT_CDEFS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GETOPT_CDEFS_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_GETOPT_CDEFS_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_GETOPT_CDEFS_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_GETOPT_CDEFS_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_GETOPT_CDEFS_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_GETOPT_CDEFS_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_GETOPT_CDEFS_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_GETOPT_CDEFS_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_GETOPT_CDEFS_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_GETOPT_CDEFS_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_GETOPT_CDEFS_H_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_GETOPT], [test $REPLACE_GETOPT = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_GETOPT], [test $REPLACE_GETOPT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETOPT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETOPT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETOPT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETOPT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETOPT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETOPT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETOPT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETOPT_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_GETOPT], [ - dnl Define the substituted variable GNULIB_UNISTD_H_GETOPT to 1. - gl_UNISTD_H_REQUIRE_DEFAULTS - gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT], [1]) - ]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT], [1]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_GETOPT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNISTD_H_GETOPT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNISTD_H_GETOPT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNISTD_H_GETOPT$]) -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([getopt-posix]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([getopt-posix]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[getopt-posix]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([getopt-posix]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_GETOPT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_GETOPT_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_GETOPT_POSIX$]) -m4trace:configure.ac:114: -1- gl_FUNC_GETPROGNAME -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([getprogname], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([getprogname], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([getprogname]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([getprogname], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([getprogname]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([getprogname]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_GETOPT_POSIX], [/* Define to 1 when the gnulib module getopt-posix should be tested. */ +@%:@undef GNULIB_TEST_GETOPT_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETPROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETPROGNAME$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETPROGNAME], [/* Define to 1 if you have the `getprogname\' function. */ +@%:@undef HAVE_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PROGRAM_INVOCATION_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_NAME$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_GETPROGNAME], [test $HAVE_GETPROGNAME = 0 || test $REPLACE_GETPROGNAME = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PROGRAM_INVOCATION_NAME], [/* Define to 1 if you have the declaration of \'program_invocation_name\', and + to 0 if you don\'t. */ +@%:@undef HAVE_DECL_PROGRAM_INVOCATION_NAME]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_GETPROGNAME], [test $HAVE_GETPROGNAME = 0 || test $REPLACE_GETPROGNAME = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETPROGNAME_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETPROGNAME_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETPROGNAME_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_GETPROGNAME_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_GETPROGNAME_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_GETPROGNAME_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETPROGNAME_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_GETPROGNAME_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_GETPROGNAME], [ - gl_PREREQ_GETPROGNAME - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_GETPROGNAME -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_getexecname], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" getexecname ]AS_TR_CPP([HAVE_getexecname])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_GETPROGNAME]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETEXECNAME], [/* Define to 1 if you have the \'getexecname\' function. */ +@%:@undef HAVE_GETEXECNAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PROGRAM_INVOCATION_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_NAME$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PROGRAM_INVOCATION_NAME], [/* Define to 1 if you have the declaration of \'program_invocation_name\', and + to 0 if you don\'t. */ +@%:@undef HAVE_DECL_PROGRAM_INVOCATION_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME], [/* Define to 1 if you have the declaration of \'program_invocation_short_name\', + and to 0 if you don\'t. */ +@%:@undef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL___ARGV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL___ARGV$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL___ARGV], [/* Define to 1 if you have the declaration of \'__argv\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL___ARGV]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_VAR___PROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VAR___PROGNAME$]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([getprogname]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([getprogname]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[getprogname]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([getprogname]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_VAR___PROGNAME], [/* Define if you have a global __progname variable */ +@%:@undef HAVE_VAR___PROGNAME]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_GETPROGNAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_GETPROGNAME$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_GETPROGNAME], [/* Define to 1 when the gnulib module getprogname should be tested. */ +@%:@undef GNULIB_TEST_GETPROGNAME]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBINTL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBINTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBINTL$]) +m4trace:configure.ac:114: -1- AC_SUBST([LTLIBINTL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LTLIBINTL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LTLIBINTL$]) -m4trace:configure.ac:114: -1- gl_FUNC_SETLOCALE_NULL -m4trace:configure.ac:114: -1- gl_PTHREADLIB -m4trace:configure.ac:114: -1- gl_PTHREADLIB_BODY +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([PTHREAD_IN_USE_DETECTION_HARD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTHREAD_IN_USE_DETECTION_HARD$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([PTHREAD_IN_USE_DETECTION_HARD], [/* Define if the pthread_in_use() detection is hard. */ +@%:@undef PTHREAD_IN_USE_DETECTION_HARD]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPTHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPMULTITHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPMULTITHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPMULTITHREAD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_API]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_API$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_API], [/* Define if you have the header and the POSIX threads API. */ +@%:@undef HAVE_PTHREAD_API]) +m4trace:configure.ac:114: -1- AC_SUBST([SCHED_YIELD_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SCHED_YIELD_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SCHED_YIELD_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SCHED_YIELD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SCHED_YIELD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SCHED_YIELD$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([SETLOCALE_NULL_ALL_MTSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_ALL_MTSAFE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([SETLOCALE_NULL_ALL_MTSAFE], [/* Define to 1 if setlocale (LC_ALL, NULL) is multithread-safe. */ +@%:@undef SETLOCALE_NULL_ALL_MTSAFE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([SETLOCALE_NULL_ONE_MTSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_ONE_MTSAFE$]) -m4trace:configure.ac:114: -1- gl_WEAK_SYMBOLS +m4trace:configure.ac:114: -1- AH_OUTPUT([SETLOCALE_NULL_ONE_MTSAFE], [/* Define to 1 if setlocale (category, NULL) is multithread-safe. */ +@%:@undef SETLOCALE_NULL_ONE_MTSAFE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WEAK_SYMBOLS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WEAK_SYMBOLS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WEAK_SYMBOLS], [/* Define to 1 if the compiler and linker support weak declarations of + symbols. */ +@%:@undef HAVE_WEAK_SYMBOLS]) +m4trace:configure.ac:114: -1- AC_SUBST([SETLOCALE_NULL_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SETLOCALE_NULL_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SETLOCALE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SETLOCALE_NULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SETLOCALE_NULL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HARD_LOCALE_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HARD_LOCALE_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HARD_LOCALE_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_HARD_LOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_HARD_LOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_HARD_LOCALE$]) -m4trace:configure.ac:114: -1- AC_DEFUN([gl_HAVE_MODULE_HAVELIB]) m4trace:configure.ac:114: -1- AM_ICONV -m4trace:configure.ac:114: -1- AM_ICONV_LINK -m4trace:configure.ac:114: -1- AM_ICONV_LINKFLAGS_BODY -m4trace:configure.ac:114: -1- AC_LIB_LINKFLAGS_BODY([iconv]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([ - eval additional_includedir=\"$includedir\" - eval additional_libdir=\"$libdir\" - eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" - eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" - ]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) -m4trace:configure.ac:114: -1- AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) -m4trace:configure.ac:114: -1- AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ICONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ICONV$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ICONV], [/* Define if you have the iconv() function and it works. */ +@%:@undef HAVE_ICONV]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBICONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBICONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBICONV$]) +m4trace:configure.ac:114: -1- AC_SUBST([LTLIBICONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LTLIBICONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LTLIBICONV$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([ICONV_CONST]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ICONV_CONST$]) -m4trace:configure.ac:114: -1- gl_ICONV_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([ICONV_CONST], [/* Define as const if the declaration of iconv() needs const. */ +@%:@undef ICONV_CONST]) +m4trace:configure.ac:114: -1- AC_SUBST([ICONV_CONST]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ICONV_CONST]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ICONV_CONST$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ICONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ICONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ICONV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ICONV_OPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ICONV_OPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ICONV_OPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ICONV_UTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ICONV_UTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ICONV_UTF$]) -m4trace:configure.ac:114: -1- gl_ICONV_MODULE_INDICATOR([iconv]) -m4trace:configure.ac:114: -1- gl_ICONV_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ICONV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ICONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ICONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ICONV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([iconv]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[iconv]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_ICONV_H -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([iconv.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([iconv.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_iconv_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" iconv.h ]AS_TR_SH([iconv.h]) AS_TR_CPP([HAVE_iconv.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([iconv.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ICONV_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_ICONV_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_ICONV_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_ICONV_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_ICONV_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_ICONV_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_ICONV_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_ICONV_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [iconv iconv_open]) -m4trace:configure.ac:114: -1- gl_ICONV_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([iconv.h]) +m4trace:configure.ac:114: -1- AC_SUBST([ICONV_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ICONV_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ICONV_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_ICONV_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_ICONV_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ICONV_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ICONV_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ICONV_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ICONV_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ICONV_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ICONV_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ICONV_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ICONV_H_FALSE]) -m4trace:configure.ac:114: -1- gl_FUNC_ICONV_OPEN -m4trace:configure.ac:114: -1- gl_REPLACE_ICONV_H -m4trace:configure.ac:114: -1- gl_ICONV_H_REQUIRE_DEFAULTS +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([ICONV_FLAVOR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ICONV_FLAVOR$]) -m4trace:configure.ac:114: -1- gl_REPLACE_ICONV_OPEN -m4trace:configure.ac:114: -1- gl_REPLACE_ICONV_H -m4trace:configure.ac:114: -1- gl_ICONV_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([iconv.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([ICONV_FLAVOR], [/* Define to a symbolic name denoting the flavor of iconv_open() + implementation. */ +@%:@undef ICONV_FLAVOR]) +m4trace:configure.ac:114: -1- AC_SUBST([ICONV_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ICONV_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ICONV_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_ICONV_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_ICONV_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ICONV_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ICONV_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ICONV_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_ICONV_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_ICONV_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_ICONV_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ICONV_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_ICONV_H_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ICONV_OPEN], [test $REPLACE_ICONV_OPEN = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ICONV_OPEN], [test $REPLACE_ICONV_OPEN = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ICONV_OPEN_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ICONV_OPEN_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ICONV_OPEN_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ICONV_OPEN_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ICONV_OPEN_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ICONV_OPEN_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ICONV_OPEN_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ICONV_OPEN_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ICONV], [test $REPLACE_ICONV = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ICONV], [test $REPLACE_ICONV = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ICONV_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ICONV_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ICONV_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ICONV_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ICONV_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ICONV_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ICONV_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ICONV_FALSE]) -m4trace:configure.ac:114: -1- gl_INLINE +m4trace:configure.ac:114: -1- AH_OUTPUT([inline], [/* Define to \'__inline__\' or \'__inline\' if that\'s what the C compiler + calls it, or to nothing if \'inline\' is not supported under any name. */ +#ifndef __cplusplus +#undef inline +#endif]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_INLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_INLINE$]) -m4trace:configure.ac:114: -1- gl_INTTYPES_INCOMPLETE -m4trace:configure.ac:114: -1- gl_STDINT_H -m4trace:configure.ac:114: -1- gl_LIMITS_H -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([limits.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([limits.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_limits_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" limits.h ]AS_TR_SH([limits.h]) AS_TR_CPP([HAVE_limits.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([limits.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_INLINE], [/* Define to 1 if the compiler supports one of the keywords \'inline\', + \'__inline__\', \'__inline\' and effectively inlines functions marked as such. + */ +@%:@undef HAVE_INLINE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LIMITS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_LIMITS_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_LIMITS_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_LIMITS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_LIMITS_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_LIMITS_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_LIMITS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_LIMITS_H$]) -m4trace:configure.ac:114: -1- gt_TYPE_WINT_T +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINT_T$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WINT_T], [/* Define if you have the \'wint_t\' type. */ +@%:@undef HAVE_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST([GNULIBHEADERS_OVERRIDE_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GNULIBHEADERS_OVERRIDE_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIBHEADERS_OVERRIDE_WINT_T$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_LONG_LONG_INT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LONG_LONG_INT$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LONG_LONG_INT], [/* Define to 1 if the system has the type \'long long int\'. */ +@%:@undef HAVE_LONG_LONG_INT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_UNSIGNED_LONG_LONG_INT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNSIGNED_LONG_LONG_INT$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_wchar_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" wchar.h ]AS_TR_SH([wchar.h]) AS_TR_CPP([HAVE_wchar.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNSIGNED_LONG_LONG_INT], [/* Define to 1 if the system has the type \'unsigned long long int\'. */ +@%:@undef HAVE_UNSIGNED_LONG_LONG_INT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCHAR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCHAR_H$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_inttypes_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" inttypes.h ]AS_TR_SH([inttypes.h]) AS_TR_CPP([HAVE_inttypes.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_INTTYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_INTTYPES_H$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_types_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/types.h ]AS_TR_SH([sys/types.h]) AS_TR_CPP([HAVE_sys/types.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_TYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_TYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_TYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_TYPES_H$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([stdint.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([stdint.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_stdint_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" stdint.h ]AS_TR_SH([stdint.h]) AS_TR_CPP([HAVE_stdint.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([stdint.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STDINT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_STDINT_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_STDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_STDINT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_STDINT_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_STDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_STDINT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STDINT_H$]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([__STDC_CONSTANT_MACROS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^__STDC_CONSTANT_MACROS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([__STDC_CONSTANT_MACROS], [/* Define to 1 if the system predates C++11. */ +@%:@undef __STDC_CONSTANT_MACROS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([__STDC_LIMIT_MACROS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^__STDC_LIMIT_MACROS$]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([__STDC_LIMIT_MACROS], [/* Define to 1 if the system predates C++11. */ +@%:@undef __STDC_LIMIT_MACROS]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SYS_INTTYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_INTTYPES_H$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_BITYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_BITYPES_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SYS_BITYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_BITYPES_H$]) -m4trace:configure.ac:114: -1- gl_STDINT_TYPE_PROPERTIES -m4trace:configure.ac:114: -1- gl_MULTIARCH +m4trace:configure.ac:114: -1- AC_SUBST([APPLE_UNIVERSAL_BUILD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([APPLE_UNIVERSAL_BUILD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^APPLE_UNIVERSAL_BUILD$]) -m4trace:configure.ac:114: -1- gl_STDINT_BITSIZEOF([ptrdiff_t size_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_PTRDIFF_T], [/* Define to the number of bits in type \'ptrdiff_t\'. */ +@%:@undef BITSIZEOF_PTRDIFF_T]) +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_SIZE_T], [/* Define to the number of bits in type \'size_t\'. */ +@%:@undef BITSIZEOF_SIZE_T]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_PTRDIFF_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_PTRDIFF_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_PTRDIFF_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_SIZE_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_SIZE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_SIZE_T$]) -m4trace:configure.ac:114: -1- gl_STDINT_BITSIZEOF([sig_atomic_t wchar_t wint_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_SIG_ATOMIC_T], [/* Define to the number of bits in type \'sig_atomic_t\'. */ +@%:@undef BITSIZEOF_SIG_ATOMIC_T]) +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_WCHAR_T], [/* Define to the number of bits in type \'wchar_t\'. */ +@%:@undef BITSIZEOF_WCHAR_T]) +m4trace:configure.ac:114: -1- AH_OUTPUT([BITSIZEOF_WINT_T], [/* Define to the number of bits in type \'wint_t\'. */ +@%:@undef BITSIZEOF_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_SIG_ATOMIC_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_SIG_ATOMIC_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_SIG_ATOMIC_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_WCHAR_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([BITSIZEOF_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([BITSIZEOF_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^BITSIZEOF_WINT_T$]) -m4trace:configure.ac:114: -1- gl_CHECK_TYPES_SIGNED([sig_atomic_t wchar_t wint_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SIGNED_SIG_ATOMIC_T], [/* Define to 1 if \'sig_atomic_t\' is a signed integer type. */ +@%:@undef HAVE_SIGNED_SIG_ATOMIC_T]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SIGNED_WCHAR_T], [/* Define to 1 if \'wchar_t\' is a signed integer type. */ +@%:@undef HAVE_SIGNED_WCHAR_T]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SIGNED_WINT_T], [/* Define to 1 if \'wint_t\' is a signed integer type. */ +@%:@undef HAVE_SIGNED_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGNED_SIG_ATOMIC_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGNED_SIG_ATOMIC_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGNED_SIG_ATOMIC_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGNED_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGNED_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGNED_WCHAR_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGNED_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGNED_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGNED_WINT_T$]) -m4trace:configure.ac:114: -1- gl_INTEGER_TYPE_SUFFIX([ptrdiff_t size_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([PTRDIFF_T_SUFFIX], [/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type + \'ptrdiff_t\'. */ +@%:@undef PTRDIFF_T_SUFFIX]) +m4trace:configure.ac:114: -1- AH_OUTPUT([SIZE_T_SUFFIX], [/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type + \'size_t\'. */ +@%:@undef SIZE_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST([PTRDIFF_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([PTRDIFF_T_SUFFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTRDIFF_T_SUFFIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([SIZE_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SIZE_T_SUFFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SIZE_T_SUFFIX$]) -m4trace:configure.ac:114: -1- gl_INTEGER_TYPE_SUFFIX([sig_atomic_t wchar_t wint_t], [gl_STDINT_INCLUDES]) -m4trace:configure.ac:114: -1- gl_STDINT_INCLUDES +m4trace:configure.ac:114: -1- AH_OUTPUT([SIG_ATOMIC_T_SUFFIX], [/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type + \'sig_atomic_t\'. */ +@%:@undef SIG_ATOMIC_T_SUFFIX]) +m4trace:configure.ac:114: -1- AH_OUTPUT([WCHAR_T_SUFFIX], [/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type + \'wchar_t\'. */ +@%:@undef WCHAR_T_SUFFIX]) +m4trace:configure.ac:114: -1- AH_OUTPUT([WINT_T_SUFFIX], [/* Define to l, ll, u, ul, ull, etc., as suitable for constants of type + \'wint_t\'. */ +@%:@undef WINT_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST([SIG_ATOMIC_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SIG_ATOMIC_T_SUFFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SIG_ATOMIC_T_SUFFIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([WCHAR_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WCHAR_T_SUFFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WCHAR_T_SUFFIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([WINT_T_SUFFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WINT_T_SUFFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WINT_T_SUFFIX$]) -m4trace:configure.ac:114: -1- gl_REPLACE_LIMITS_H +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_C99_STDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_C99_STDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C99_STDINT_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_BITYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_BITYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_BITYPES_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SYS_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SYS_INTTYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_INTTYPES_H$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_inttypes_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" inttypes.h ]AS_TR_SH([inttypes.h]) AS_TR_CPP([HAVE_inttypes.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_INTTYPES_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_IMAXABS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_IMAXABS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_IMAXABS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_IMAXDIV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_IMAXDIV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_IMAXDIV$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRTOIMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRTOIMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRTOIMAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRTOUMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRTOUMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRTOUMAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_IMAXDIV_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_IMAXDIV_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_IMAXDIV_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_IMAXABS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_IMAXABS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_IMAXABS$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_IMAXDIV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_IMAXDIV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_IMAXDIV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_IMAXABS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_IMAXABS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_IMAXABS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_IMAXDIV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_IMAXDIV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_IMAXDIV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOIMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOIMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOIMAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOUMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOUMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOUMAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([INT32_MAX_LT_INTMAX_MAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([INT32_MAX_LT_INTMAX_MAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INT32_MAX_LT_INTMAX_MAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([INT64_MAX_EQ_LONG_MAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([INT64_MAX_EQ_LONG_MAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INT64_MAX_EQ_LONG_MAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([PRIPTR_PREFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([PRIPTR_PREFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PRIPTR_PREFIX$]) +m4trace:configure.ac:114: -1- AC_SUBST([UINT32_MAX_LT_UINTMAX_MAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UINT32_MAX_LT_UINTMAX_MAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UINT32_MAX_LT_UINTMAX_MAX$]) +m4trace:configure.ac:114: -1- AC_SUBST([UINT64_MAX_EQ_ULONG_MAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UINT64_MAX_EQ_ULONG_MAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UINT64_MAX_EQ_ULONG_MAX$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([inttypes.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([inttypes.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_inttypes_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" inttypes.h ]AS_TR_SH([inttypes.h]) AS_TR_CPP([HAVE_inttypes.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([inttypes.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_INTTYPES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_INTTYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_INTTYPES_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_INTTYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_INTTYPES_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_INTTYPES_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_INTTYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_INTTYPES_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [imaxabs imaxdiv strtoimax strtoumax]) -m4trace:configure.ac:114: -1- gl_INTTYPES_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_IMAXABS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_IMAXABS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_IMAXABS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_IMAXABS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_IMAXDIV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_IMAXDIV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_IMAXDIV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_IMAXDIV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOIMAX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOIMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOIMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOIMAX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOUMAX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOUMAX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOUMAX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOUMAX$]) -m4trace:configure.ac:114: -1- gl_FUNC_ISWBLANK -m4trace:configure.ac:114: -1- gl_WCTYPE_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ISWBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ISWBLANK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCTYPE_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCTYPE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCTYPE_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCTRANS_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCTRANS_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCTRANS_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISWBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISWBLANK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISWDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISWDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISWDIGIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISWPUNCT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISWPUNCT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISWPUNCT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISWXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISWXDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISWXDIGIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCTRANS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCTRANS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCTRANS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_WCTYPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_WCTYPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_WCTYPE$]) -m4trace:configure.ac:114: -1- gl_WCTYPE_H -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_iswcntrl], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" iswcntrl ]AS_TR_CPP([HAVE_iswcntrl])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ISWCNTRL], [/* Define to 1 if you have the \'iswcntrl\' function. */ +@%:@undef HAVE_ISWCNTRL]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_ISWCNTRL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_ISWCNTRL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ISWCNTRL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINT_T$]) -m4trace:configure.ac:114: -1- gl_TYPE_WINT_T_PREREQ -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_crtdefs_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" crtdefs.h ]AS_TR_SH([crtdefs.h]) AS_TR_CPP([HAVE_crtdefs.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_CRTDEFS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_CRTDEFS_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_CRTDEFS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_CRTDEFS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_CRTDEFS_H$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([wctype.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([wctype.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_wctype_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" wctype.h ]AS_TR_SH([wctype.h]) AS_TR_CPP([HAVE_wctype.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([wctype.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCTYPE_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WCTYPE_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_WCTYPE_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_WCTYPE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_WCTYPE_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_WCTYPE_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_WCTYPE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_WCTYPE_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCTYPE_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCTYPE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCTYPE_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_ISWCNTRL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_ISWCNTRL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_ISWCNTRL$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_TOWLOWER], [/* Define to 1 if you have the \'towlower\' function. */ +@%:@undef HAVE_TOWLOWER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_TOWLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TOWLOWER$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_TOWLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_TOWLOWER$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_TOWLOWER], [/* Define to 1 if you have the declaration of \'towlower\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_TOWLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TOWLOWER]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TOWLOWER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TOWLOWER$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[ -#if !(defined __GLIBC__ && !defined __UCLIBC__) -# include -#endif -#include - ]], [wctype iswctype wctrans towctrans - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([iswblank], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([iswblank], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([iswblank]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([iswblank], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([iswblank]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([iswblank]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_ISWBLANK$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_ISWBLANK], [/* Define to 1 if you have the `iswblank\' function. */ +@%:@undef HAVE_ISWBLANK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_ISWBLANK$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ISWBLANK], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && { test $HAVE_ISWBLANK = 0 || test $REPLACE_ISWBLANK = 1; }]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_ISWBLANK], [/* Define to 1 if you have the declaration of \'iswblank\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_ISWBLANK]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ISWBLANK], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && { test $HAVE_ISWBLANK = 0 || test $REPLACE_ISWBLANK = 1; }]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWBLANK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWBLANK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWBLANK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWBLANK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWBLANK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWBLANK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWBLANK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWBLANK_FALSE]) -m4trace:configure.ac:114: -1- gl_WCTYPE_MODULE_INDICATOR([iswblank]) -m4trace:configure.ac:114: -1- gl_WCTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISWBLANK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISWBLANK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISWDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISWDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISWDIGIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWPUNCT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISWPUNCT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISWPUNCT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISWPUNCT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISWXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISWXDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISWXDIGIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTYPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCTYPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCTYPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCTYPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_ISWCTYPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_ISWCTYPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_ISWCTYPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_ISWCTYPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTRANS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCTRANS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCTRANS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCTRANS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TOWCTRANS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TOWCTRANS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TOWCTRANS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TOWCTRANS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([iswblank]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[iswblank]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([iswblank]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_ISWBLANK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_ISWBLANK$]) -m4trace:configure.ac:114: -1- gl_FUNC_ISWDIGIT -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ISWDIGIT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWDIGIT = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_ISWBLANK], [/* Define to 1 when the gnulib module iswblank should be tested. */ +@%:@undef GNULIB_TEST_ISWBLANK]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ISWDIGIT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWDIGIT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWDIGIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWDIGIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWDIGIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWDIGIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWDIGIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWDIGIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWDIGIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWDIGIT_FALSE]) -m4trace:configure.ac:114: -1- gl_WCTYPE_MODULE_INDICATOR([iswdigit]) -m4trace:configure.ac:114: -1- gl_WCTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([iswdigit]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[iswdigit]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([iswdigit]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_ISWDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_ISWDIGIT$]) -m4trace:configure.ac:114: -1- gl_FUNC_ISWPUNCT -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ISWPUNCT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWPUNCT = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_ISWDIGIT], [/* Define to 1 when the gnulib module iswdigit should be tested. */ +@%:@undef GNULIB_TEST_ISWDIGIT]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ISWPUNCT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWPUNCT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWPUNCT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWPUNCT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWPUNCT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWPUNCT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWPUNCT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWPUNCT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWPUNCT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWPUNCT_FALSE]) -m4trace:configure.ac:114: -1- gl_WCTYPE_MODULE_INDICATOR([iswpunct]) -m4trace:configure.ac:114: -1- gl_WCTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([iswpunct]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[iswpunct]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([iswpunct]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_ISWPUNCT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_ISWPUNCT$]) -m4trace:configure.ac:114: -1- gl_FUNC_ISWXDIGIT -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_ISWXDIGIT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWXDIGIT = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_ISWPUNCT], [/* Define to 1 when the gnulib module iswpunct should be tested. */ +@%:@undef GNULIB_TEST_ISWPUNCT]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_ISWXDIGIT], [! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWXDIGIT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWXDIGIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWXDIGIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWXDIGIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_ISWXDIGIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_ISWXDIGIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_ISWXDIGIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWXDIGIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_ISWXDIGIT_FALSE]) -m4trace:configure.ac:114: -1- gl_WCTYPE_MODULE_INDICATOR([iswxdigit]) -m4trace:configure.ac:114: -1- gl_WCTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([iswxdigit]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[iswxdigit]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([iswxdigit]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_ISWXDIGIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_ISWXDIGIT$]) -m4trace:configure.ac:114: -1- gt_JAVA_CHOICE +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_ISWXDIGIT], [/* Define to 1 when the gnulib module iswxdigit should be tested. */ +@%:@undef GNULIB_TEST_ISWXDIGIT]) +m4trace:configure.ac:114: -1- AC_SUBST([JAVA_CHOICE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([JAVA_CHOICE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^JAVA_CHOICE$]) -m4trace:configure.ac:114: -1- gl_LANGINFO_H -m4trace:configure.ac:114: -1- gl_LANGINFO_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_CONFIG_FILES([javacomp.sh:../build-aux/javacomp.sh.in]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_NL_LANGINFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_NL_LANGINFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_NL_LANGINFO$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_NL_LANGINFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_NL_LANGINFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_NL_LANGINFO$]) -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([langinfo.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([langinfo.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_langinfo_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" langinfo.h ]AS_TR_SH([langinfo.h]) AS_TR_CPP([HAVE_langinfo.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([langinfo.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LANGINFO_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_LANGINFO_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_LANGINFO_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_LANGINFO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_LANGINFO_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_LANGINFO_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_LANGINFO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_LANGINFO_H$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_langinfo_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" langinfo.h ]AS_TR_SH([langinfo.h]) AS_TR_CPP([HAVE_langinfo.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LANGINFO_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_LANGINFO_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_CODESET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_CODESET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_CODESET$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_T_FMT_AMPM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_T_FMT_AMPM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_T_FMT_AMPM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_ALTMON]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_ALTMON]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_ALTMON$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_ERA]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_ERA]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_ERA$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_LANGINFO_YESEXPR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_LANGINFO_YESEXPR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LANGINFO_YESEXPR$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [nl_langinfo]) -m4trace:configure.ac:114: -1- gl_LANGINFO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NL_LANGINFO]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_NL_LANGINFO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_NL_LANGINFO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_NL_LANGINFO$]) -m4trace:configure.ac:114: -1- gl___INLINE +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE___INLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE___INLINE$]) -m4trace:configure.ac:114: -1- gl_LIMITS_H -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([limits.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE___INLINE], [/* Define to 1 if the compiler supports the keyword \'__inline\'. */ +@%:@undef HAVE___INLINE]) +m4trace:configure.ac:114: -1- AC_SUBST([LIMITS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIMITS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIMITS_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_LIMITS_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_LIMITS_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_LIMITS_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_LIMITS_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_LIMITS_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_LIMITS_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_LIMITS_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_LIMITS_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_LIMITS_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_LIMITS_H_FALSE]) -m4trace:configure.ac:114: -1- gl_LOCALCHARSET +m4trace:configure.ac:114: -1- AC_SUBST([LOCALCHARSET_TESTS_ENVIRONMENT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALCHARSET_TESTS_ENVIRONMENT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALCHARSET_TESTS_ENVIRONMENT$]) -m4trace:configure.ac:114: -1- gl_LOCALE_H -m4trace:configure.ac:114: -1- gl_LOCALE_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_NEWLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_NEWLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_NEWLOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DUPLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DUPLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DUPLOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FREELOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FREELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FREELOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LOCALECONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LOCALECONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LOCALECONV$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SETLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SETLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SETLOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_NEWLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_NEWLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_NEWLOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_DUPLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_DUPLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_DUPLOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FREELOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FREELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FREELOCALE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRUCT_LCONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRUCT_LCONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRUCT_LCONV$]) +m4trace:configure.ac:114: -1- AC_SUBST([LOCALENAME_ENHANCE_LOCALE_FUNCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LOCALENAME_ENHANCE_LOCALE_FUNCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALENAME_ENHANCE_LOCALE_FUNCS$]) -m4trace:configure.ac:114: -1- gl_STDDEF_H -m4trace:configure.ac:114: -1- gl_STDDEF_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_NULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_NULL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MAX_ALIGN_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MAX_ALIGN_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MAX_ALIGN_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCHAR_T$]) -m4trace:configure.ac:114: -1- gt_TYPE_WCHAR_T +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WCHAR_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCHAR_T$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([stddef.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([stddef.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([stddef.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCHAR_T], [/* Define if you have the \'wchar_t\' type. */ +@%:@undef HAVE_WCHAR_T]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_STDDEF_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_STDDEF_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_STDDEF_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_STDDEF_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_STDDEF_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_STDDEF_H$]) -m4trace:configure.ac:114: -1- gl_LOCALE_T -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_xlocale_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" xlocale.h ]AS_TR_SH([xlocale.h]) AS_TR_CPP([HAVE_xlocale.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_XLOCALE_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_XLOCALE_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_XLOCALE_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_XLOCALE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_XLOCALE_H$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([_LCONV_C99]) m4trace:configure.ac:114: -1- m4_pattern_allow([^_LCONV_C99$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([locale.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([locale.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([locale.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([_LCONV_C99], [/* Define to 1 on Solaris. */ +@%:@undef _LCONV_C99]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_LOCALE_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_LOCALE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_LOCALE_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_LOCALE_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_LOCALE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_LOCALE_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include -/* Some systems provide declarations in a non-standard header. */ -#if HAVE_XLOCALE_H -# include -#endif - ]], [setlocale newlocale duplocale freelocale]) -m4trace:configure.ac:114: -1- gl_LOCALE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALECONV]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LOCALECONV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LOCALECONV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LOCALECONV$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SETLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SETLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SETLOCALE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SETLOCALE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SETLOCALE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SETLOCALE_NULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SETLOCALE_NULL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DUPLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_DUPLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_DUPLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_DUPLOCALE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALENAME_UNSAFE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LOCALENAME_UNSAFE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LOCALENAME_UNSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LOCALENAME_UNSAFE$]) -m4trace:configure.ac:114: -1- gl_LOCALENAME_UNSAFE -m4trace:configure.ac:114: -1- gt_LC_MESSAGES +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_LC_MESSAGES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_LC_MESSAGES$]) -m4trace:configure.ac:114: -1- gt_INTL_THREAD_LOCALE_NAME -m4trace:configure.ac:114: -1- gt_FUNC_USELOCALE -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([uselocale], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([uselocale], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([uselocale]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([uselocale], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([uselocale]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([uselocale]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LC_MESSAGES], [/* Define if your file defines LC_MESSAGES. */ +@%:@undef HAVE_LC_MESSAGES]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_USELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_USELOCALE$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_xlocale_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" xlocale.h ]AS_TR_SH([xlocale.h]) AS_TR_CPP([HAVE_xlocale.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_USELOCALE], [/* Define to 1 if you have the `uselocale\' function. */ +@%:@undef HAVE_USELOCALE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_XLOCALE_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_XLOCALE_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WORKING_USELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WORKING_USELOCALE$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_xlocale_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" xlocale.h ]AS_TR_SH([xlocale.h]) AS_TR_CPP([HAVE_xlocale.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WORKING_USELOCALE], [/* Define if the uselocale function exists and may safely be called. */ +@%:@undef HAVE_WORKING_USELOCALE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_XLOCALE_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_XLOCALE_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FAKE_LOCALES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FAKE_LOCALES$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FAKE_LOCALES], [/* Define if the locale_t type contains insufficient information, as on + OpenBSD. */ +@%:@undef HAVE_FAKE_LOCALES]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SOLARIS114_LOCALES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SOLARIS114_LOCALES$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SOLARIS114_LOCALES], [/* Define if the locale_t type is as on Solaris 11.4. */ +@%:@undef HAVE_SOLARIS114_LOCALES]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETLOCALENAME_L], [/* Define to 1 if you have the \'getlocalename_l\' function. */ +@%:@undef HAVE_GETLOCALENAME_L]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETLOCALENAME_L]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETLOCALENAME_L$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_NAMELESS_LOCALES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_NAMELESS_LOCALES$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_NAMELESS_LOCALES], [/* Define if the locale_t type does not contain the name of each locale + category. */ +@%:@undef HAVE_NAMELESS_LOCALES]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_AIX72_LOCALES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_AIX72_LOCALES$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_AIX72_LOCALES], [/* Define if the __locale_t type contains the name of the LC_MESSAGES + category. */ +@%:@undef HAVE_AIX72_LOCALES]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GOOD_USELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GOOD_USELOCALE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GOOD_USELOCALE], [/* Define if the uselocale function exists, may be safely called, and returns + sufficient information. */ +@%:@undef HAVE_GOOD_USELOCALE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([LOCALENAME_ENHANCE_LOCALE_FUNCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LOCALENAME_ENHANCE_LOCALE_FUNCS$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_langinfo_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" langinfo.h ]AS_TR_SH([langinfo.h]) AS_TR_CPP([HAVE_langinfo.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([newlocale], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([newlocale], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([newlocale]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([newlocale], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([newlocale]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([newlocale]) +m4trace:configure.ac:114: -1- AH_OUTPUT([LOCALENAME_ENHANCE_LOCALE_FUNCS], [/* Define if localename.c overrides newlocale(), duplocale(), freelocale(). */ +@%:@undef LOCALENAME_ENHANCE_LOCALE_FUNCS]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LANGINFO_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_LANGINFO_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_NEWLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_NEWLOCALE$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([duplocale], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([duplocale], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([duplocale]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([duplocale], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([duplocale]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([duplocale]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_NEWLOCALE], [/* Define to 1 if you have the `newlocale\' function. */ +@%:@undef HAVE_NEWLOCALE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DUPLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DUPLOCALE$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([freelocale], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([freelocale], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([freelocale]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([freelocale], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([freelocale]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([freelocale]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DUPLOCALE], [/* Define to 1 if you have the `duplocale\' function. */ +@%:@undef HAVE_DUPLOCALE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FREELOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FREELOCALE$]) -m4trace:configure.ac:114: -1- gl_LOCALE_MODULE_INDICATOR([localename-unsafe]) -m4trace:configure.ac:114: -1- gl_LOCALE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([localename-unsafe]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[localename-unsafe]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([localename-unsafe]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FREELOCALE], [/* Define to 1 if you have the `freelocale\' function. */ +@%:@undef HAVE_FREELOCALE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_LOCALENAME_UNSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_LOCALENAME_UNSAFE$]) -m4trace:configure.ac:114: -1- gl_MUSL_LIBC +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_LOCALENAME_UNSAFE], [/* Define to 1 when the gnulib module localename-unsafe should be tested. */ +@%:@undef GNULIB_TEST_LOCALENAME_UNSAFE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MUSL_LIBC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MUSL_LIBC$]) -m4trace:configure.ac:114: -1- gl_LOCALENAME_UNSAFE_LIMITED -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED], [case "$host_os" in netbsd* | solaris*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MUSL_LIBC], [/* Define to 1 on musl libc. */ +@%:@undef MUSL_LIBC]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED], [case "$host_os" in netbsd* | solaris*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED_FALSE]) -m4trace:configure.ac:114: -1- gl_LOCK -m4trace:configure.ac:114: -1- gl_THREADLIB -m4trace:configure.ac:114: -1- gl_THREADLIB_BODY -m4trace:configure.ac:114: -1- gl_WEAK_SYMBOLS +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WEAK_SYMBOLS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WEAK_SYMBOLS$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_PTHREADLIB_BODY +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WEAK_SYMBOLS], [/* Define to 1 if the compiler and linker support weak declarations of + symbols. */ +@%:@undef HAVE_WEAK_SYMBOLS]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([PTHREAD_IN_USE_DETECTION_HARD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTHREAD_IN_USE_DETECTION_HARD$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([PTHREAD_IN_USE_DETECTION_HARD], [/* Define if the pthread_in_use() detection is hard. */ +@%:@undef PTHREAD_IN_USE_DETECTION_HARD]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPTHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPMULTITHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPMULTITHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPMULTITHREAD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_API]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_API$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_API], [/* Define if you have the header and the POSIX threads API. */ +@%:@undef HAVE_PTHREAD_API]) +m4trace:configure.ac:114: -1- AC_SUBST([SCHED_YIELD_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SCHED_YIELD_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SCHED_YIELD_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SCHED_YIELD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SCHED_YIELD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SCHED_YIELD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_ISOC_AND_POSIX_THREADS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_ISOC_AND_POSIX_THREADS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_ISOC_AND_POSIX_THREADS], [/* Define if the combination of the ISO C and POSIX multithreading APIs can be + used. */ +@%:@undef USE_ISOC_AND_POSIX_THREADS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_POSIX_THREADS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_POSIX_THREADS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_POSIX_THREADS], [/* Define if the POSIX multithreading library can be used. */ +@%:@undef USE_POSIX_THREADS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_POSIX_THREADS_FROM_LIBC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_POSIX_THREADS_FROM_LIBC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_POSIX_THREADS_FROM_LIBC], [/* Define if references to the POSIX multithreading library are satisfied by + libc. */ +@%:@undef USE_POSIX_THREADS_FROM_LIBC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_POSIX_THREADS_WEAK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_POSIX_THREADS_WEAK$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_POSIX_THREADS_WEAK], [/* Define if references to the POSIX multithreading library should be made + weak. */ +@%:@undef USE_POSIX_THREADS_WEAK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([PTHREAD_IN_USE_DETECTION_HARD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTHREAD_IN_USE_DETECTION_HARD$]) -m4trace:configure.ac:114: -1- gl_STDTHREADLIB_BODY -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_PTHREADLIB_BODY +m4trace:configure.ac:114: -1- AH_OUTPUT([PTHREAD_IN_USE_DETECTION_HARD], [/* Define if the pthread_in_use() detection is hard. */ +@%:@undef PTHREAD_IN_USE_DETECTION_HARD]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([PTHREAD_IN_USE_DETECTION_HARD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTHREAD_IN_USE_DETECTION_HARD$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([PTHREAD_IN_USE_DETECTION_HARD], [/* Define if the pthread_in_use() detection is hard. */ +@%:@undef PTHREAD_IN_USE_DETECTION_HARD]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPTHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBPMULTITHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBPMULTITHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBPMULTITHREAD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_API]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_API$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_API], [/* Define if you have the header and the POSIX threads API. */ +@%:@undef HAVE_PTHREAD_API]) +m4trace:configure.ac:114: -1- AC_SUBST([SCHED_YIELD_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SCHED_YIELD_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SCHED_YIELD_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SCHED_YIELD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SCHED_YIELD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SCHED_YIELD$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([thrd_create], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([thrd_create], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([thrd_create]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([thrd_create], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([thrd_create]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([thrd_create]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_THRD_CREATE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_THRD_CREATE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THRD_CREATE], [/* Define to 1 if you have the `thrd_create\' function. */ +@%:@undef HAVE_THRD_CREATE]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBSTDTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBSTDTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBSTDTHREAD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_ISOC_THREADS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_ISOC_THREADS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_ISOC_THREADS], [/* Define if the ISO C multithreading library can be used. */ +@%:@undef USE_ISOC_THREADS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_WINDOWS_THREADS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_WINDOWS_THREADS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_WINDOWS_THREADS], [/* Define if the native Windows multithreading API can be used. */ +@%:@undef USE_WINDOWS_THREADS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([AVOID_ANY_THREADS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^AVOID_ANY_THREADS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([AVOID_ANY_THREADS], [/* Define if no multithread safety and no multithreading is desired. */ +@%:@undef AVOID_ANY_THREADS]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBTHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LTLIBTHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LTLIBTHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LTLIBTHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBMULTITHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBMULTITHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBMULTITHREAD$]) +m4trace:configure.ac:114: -1- AC_SUBST([LTLIBMULTITHREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LTLIBMULTITHREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LTLIBMULTITHREAD$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_RWLOCK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_RWLOCK$]) -m4trace:configure.ac:114: -1- gl_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_RWLOCK], [/* Define if the POSIX multithreading library has read/write locks. */ +@%:@undef HAVE_PTHREAD_RWLOCK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER], [/* Define if the \'pthread_rwlock_rdlock\' function prefers a writer to a + reader. */ +@%:@undef HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_PTHREAD_MUTEX_RECURSIVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_MUTEX_RECURSIVE$]) -m4trace:configure.ac:114: -1- gl_PREREQ_LOCK -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([lock]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_PTHREAD_MUTEX_RECURSIVE], [/* Define if the defines PTHREAD_MUTEX_RECURSIVE. */ +@%:@undef HAVE_PTHREAD_MUTEX_RECURSIVE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_LOCK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_LOCK$]) -m4trace:configure.ac:114: -1- gl_FUNC_MALLOC_GNU -m4trace:configure.ac:114: -1- _AC_FUNC_MALLOC_IF([], [REPLACE_MALLOC_FOR_MALLOC_GNU=1]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([malloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([malloc-gnu]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([malloc-gnu]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[malloc-gnu]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([malloc-gnu]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_LOCK], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module lock shall be considered present. */ +@%:@undef GNULIB_LOCK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([malloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([malloc-posix]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([malloc-posix]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[malloc-posix]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([malloc-posix]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MALLOC_GNU], [/* Define to 1 when the gnulib module malloc-gnu should be tested. */ +@%:@undef GNULIB_TEST_MALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_MALLOCA -m4trace:configure.ac:114: -1- gl_EEMALLOC -m4trace:configure.ac:114: -1- _AC_FUNC_MALLOC_IF([gl_cv_func_malloc_0_nonnull=1], [gl_cv_func_malloc_0_nonnull=0]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MALLOC_POSIX], [/* Define to 1 when the gnulib module malloc-posix should be tested. */ +@%:@undef GNULIB_TEST_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MALLOC_0_IS_NONNULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MALLOC_0_IS_NONNULL$]) -m4trace:configure.ac:114: -1- gl_MBCHAR -m4trace:configure.ac:114: -1- gl_FUNC_MBRTOC32 -m4trace:configure.ac:114: -1- gl_MBRTOC32_EMPTY_INPUT -m4trace:configure.ac:114: -1- gl_MBRTOC32_C_LOCALE +m4trace:configure.ac:114: -1- AH_OUTPUT([MALLOC_0_IS_NONNULL], [/* If malloc(0) is != NULL, define this to 1. Otherwise define this to 0. */ +@%:@undef MALLOC_0_IS_NONNULL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOC32_EMPTY_INPUT_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOC32_EMPTY_INPUT_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOC32_EMPTY_INPUT_BUG], [/* Define if the mbrtoc32 function does not return (size_t) -2 for empty + input. */ +@%:@undef MBRTOC32_EMPTY_INPUT_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MBRTOC32], [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ], [/* Define if the mbrtoc32 function may signal encoding errors in the C locale. + */ +@%:@undef MBRTOC32_IN_C_LOCALE_MAYBE_EILSEQ]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MBRTOC32], [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBRTOC32_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBRTOC32_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBRTOC32_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBRTOC32_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBRTOC32_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBRTOC32_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBRTOC32_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBRTOC32_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MBRTOC32], [ - if test $REPLACE_MBSTATE_T = 1; then - AC_LIBOBJ([lc-charset-dispatch]) - AC_LIBOBJ([mbtowc-lock]) - gl_PREREQ_MBTOWC_LOCK - fi - gl_PREREQ_MBRTOC32 - ]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([lc-charset-dispatch.c]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([mbtowc-lock.c]) -m4trace:configure.ac:114: -1- gl_PREREQ_MBTOWC_LOCK -m4trace:configure.ac:114: -1- gl_VISIBILITY +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_SUBST([CFLAG_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([CFLAG_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^CFLAG_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) -m4trace:configure.ac:114: -1- gl_PREREQ_MBRTOC32 -m4trace:configure.ac:114: -1- gl_UCHAR_MODULE_INDICATOR([mbrtoc32]) -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbrtoc32]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbrtoc32]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbrtoc32]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_VISIBILITY], [/* Define to 1 or 0, depending whether the compiler supports simple visibility + declarations. */ +@%:@undef HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MBRTOC32]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBRTOC32]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBRTOC32$]) -m4trace:configure.ac:114: -1- gl_FUNC_MBRTOWC -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_MBSTATE_T_BROKEN -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mbrtowc], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mbrtowc ]AS_TR_CPP([HAVE_mbrtowc])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBRTOC32], [/* Define to 1 when the gnulib module mbrtoc32 should be tested. */ +@%:@undef GNULIB_TEST_MBRTOC32]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBRTOWC], [/* Define to 1 if you have the \'mbrtowc\' function. */ +@%:@undef HAVE_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_MBRTOWC$]) -m4trace:configure.ac:114: -1- gl_MBRTOWC_NULL_ARG1 -m4trace:configure.ac:114: -1- gl_MBRTOWC_NULL_ARG2 -m4trace:configure.ac:114: -1- gl_MBRTOWC_RETVAL -m4trace:configure.ac:114: -1- gl_MBRTOWC_NUL_RETVAL -m4trace:configure.ac:114: -1- gl_MBRTOWC_STORES_INCOMPLETE -m4trace:configure.ac:114: -1- gl_MBRTOWC_EMPTY_INPUT -m4trace:configure.ac:114: -1- gl_MBRTOWC_C_LOCALE +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_MBRTOWC], [/* Define to 1 if you have the declaration of \'mbrtowc\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_NULL_ARG1_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_NULL_ARG1_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_NULL_ARG1_BUG], [/* Define if the mbrtowc function has the NULL pwc argument bug. */ +@%:@undef MBRTOWC_NULL_ARG1_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_NULL_ARG2_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_NULL_ARG2_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_NULL_ARG2_BUG], [/* Define if the mbrtowc function has the NULL string argument bug. */ +@%:@undef MBRTOWC_NULL_ARG2_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_RETVAL_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_RETVAL_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_RETVAL_BUG], [/* Define if the mbrtowc function returns a wrong return value. */ +@%:@undef MBRTOWC_RETVAL_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_NUL_RETVAL_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_NUL_RETVAL_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_NUL_RETVAL_BUG], [/* Define if the mbrtowc function does not return 0 for a NUL character. */ +@%:@undef MBRTOWC_NUL_RETVAL_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_STORES_INCOMPLETE_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_STORES_INCOMPLETE_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_STORES_INCOMPLETE_BUG], [/* Define if the mbrtowc function stores a wide character when reporting + incomplete input. */ +@%:@undef MBRTOWC_STORES_INCOMPLETE_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_EMPTY_INPUT_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_EMPTY_INPUT_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_EMPTY_INPUT_BUG], [/* Define if the mbrtowc function does not return (size_t) -2 for empty input. + */ +@%:@undef MBRTOWC_EMPTY_INPUT_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ$]) -m4trace:configure.ac:114: -1- gl_WEAK_SYMBOLS +m4trace:configure.ac:114: -1- AH_OUTPUT([MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ], [/* Define if the mbrtowc function may signal encoding errors in the C locale. + */ +@%:@undef MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WEAK_SYMBOLS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WEAK_SYMBOLS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WEAK_SYMBOLS], [/* Define to 1 if the compiler and linker support weak declarations of + symbols. */ +@%:@undef HAVE_WEAK_SYMBOLS]) +m4trace:configure.ac:114: -1- AC_SUBST([MBRTOWC_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([MBRTOWC_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MBRTOWC_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_MBRTOWC$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MBRTOWC], [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MBRTOWC], [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBRTOWC_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBRTOWC_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBRTOWC_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBRTOWC_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBRTOWC_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBRTOWC_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBRTOWC_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBRTOWC_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MBRTOWC], [ - if test $REPLACE_MBSTATE_T = 1; then - AC_LIBOBJ([lc-charset-dispatch]) - AC_LIBOBJ([mbtowc-lock]) - gl_PREREQ_MBTOWC_LOCK - fi - gl_PREREQ_MBRTOWC - ]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([lc-charset-dispatch.c]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([mbtowc-lock.c]) -m4trace:configure.ac:114: -1- gl_PREREQ_MBTOWC_LOCK -m4trace:configure.ac:114: -1- gl_VISIBILITY +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST([CFLAG_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([CFLAG_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^CFLAG_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) -m4trace:configure.ac:114: -1- gl_PREREQ_MBRTOWC -m4trace:configure.ac:114: -1- gl_WCHAR_MODULE_INDICATOR([mbrtowc]) -m4trace:configure.ac:114: -1- gl_WCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_BTOWC]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_VISIBILITY], [/* Define to 1 or 0, depending whether the compiler supports simple visibility + declarations. */ +@%:@undef HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_BTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_BTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_BTOWC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCTOB]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCTOB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCTOB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCTOB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSINIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSINIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSINIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSINIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSZERO]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSZERO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSZERO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSZERO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBRTOWC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBRTOWC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBRLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBRLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBRLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBRLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSRTOWCS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSNRTOWCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSNRTOWCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSNRTOWCS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCRTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCRTOMB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCRTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCRTOMB$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSRTOMBS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNRTOMBS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNRTOMBS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNRTOMBS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCWIDTH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMCMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMMOVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMMOVE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMPCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WMEMSET]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WMEMSET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WMEMSET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WMEMSET$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCPCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCPNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCPNCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNCAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNCMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCASECMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSNCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSNCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSNCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSNCASECMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCOLL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCOLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCOLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCOLL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSXFRM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSXFRM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSXFRM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSXFRM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSDUP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSDUP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSRCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSRCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSCSPN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSCSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSCSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSCSPN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSSPN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSSPN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSPBRK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSPBRK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSSTR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSTOK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSTOK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSTOK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSTOK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSWIDTH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSWIDTH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WCSFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WCSFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WCSFTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WCSFTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_WGETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_WGETCWD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_WGETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_WGETCWD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_WCSDUP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_WCSDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_WCSDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_WCSDUP$]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbrtowc]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbrtowc]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbrtowc]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBRTOWC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBRTOWC$]) -m4trace:configure.ac:114: -1- gl_FUNC_MBSINIT -m4trace:configure.ac:114: -1- gl_MBSTATE_T_BROKEN -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mbsinit], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mbsinit ]AS_TR_CPP([HAVE_mbsinit])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBRTOWC], [/* Define to 1 when the gnulib module mbrtowc should be tested. */ +@%:@undef GNULIB_TEST_MBRTOWC]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBSINIT], [/* Define to 1 if you have the \'mbsinit\' function. */ +@%:@undef HAVE_MBSINIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_MBSINIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_MBSINIT$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MBSINIT], [test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_MBSINIT], [/* Define to 1 if you have the declaration of \'mbsinit\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_MBSINIT]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MBSINIT], [test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBSINIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBSINIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBSINIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MBSINIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MBSINIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MBSINIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBSINIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MBSINIT_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MBSINIT], [ - gl_PREREQ_MBSINIT - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_MBSINIT -m4trace:configure.ac:114: -1- gl_WCHAR_MODULE_INDICATOR([mbsinit]) -m4trace:configure.ac:114: -1- gl_WCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbsinit]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbsinit]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbsinit]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MBSINIT]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MBSINIT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBSINIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBSINIT$]) -m4trace:configure.ac:114: -1- gl_FUNC_MBSLEN -m4trace:configure.ac:114: -1- gl_STRING_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBSINIT], [/* Define to 1 when the gnulib module mbsinit should be tested. */ +@%:@undef GNULIB_TEST_MBSINIT]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MBSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MBSLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MBSLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_EXPLICIT_BZERO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_EXPLICIT_BZERO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_EXPLICIT_BZERO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FFSL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FFSL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FFSL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FFSLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FFSLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FFSLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_MEMMEM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_MEMMEM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_MEMMEM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MEMPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_MEMSET_EXPLICIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_MEMSET_EXPLICIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MEMSET_EXPLICIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_MEMRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_MEMRCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_MEMRCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RAWMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RAWMEMCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STPNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STPNCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRCHRNUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRCHRNUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRCHRNUL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRNDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRNDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRNDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRNLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRPBRK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRPBRK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRSEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRSEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRSEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRCASESTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRCASESTR$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRTOK_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRTOK_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRERROR_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRERROR_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRERRORNAME_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRERRORNAME_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRERRORNAME_NP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGABBREV_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGABBREV_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGABBREV_NP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGDESCR_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGDESCR_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGDESCR_NP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_STRSIGNAL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_STRSIGNAL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRSIGNAL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRVERSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRVERSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRVERSCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FFSLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FFSLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FFSLL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MEMCHR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MEMMEM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MEMMEM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MEMMEM$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MEMPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MEMSET_EXPLICIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MEMSET_EXPLICIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MEMSET_EXPLICIT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STPCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STPNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STPNCPY$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRCHRNUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRCHRNUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRCHRNUL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRNCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRNCAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRNDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRNDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRNDUP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRNLEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRSTR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRCASESTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRCASESTR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRTOK_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRTOK_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRERROR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRERROR_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRERROR_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRERRORNAME_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRERRORNAME_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRERRORNAME_NP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRSIGNAL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRSIGNAL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRSIGNAL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRVERSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRVERSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRVERSCMP$]) +m4trace:configure.ac:114: -1- AC_SUBST([UNDEFINE_STRTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UNDEFINE_STRTOK_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UNDEFINE_STRTOK_R$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mbslen], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mbslen ]AS_TR_CPP([HAVE_mbslen])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([mbslen]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_EXPLICIT_BZERO]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MBSLEN], [/* Define to 1 if you have the \'mbslen\' function. */ +@%:@undef HAVE_MBSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_EXPLICIT_BZERO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_EXPLICIT_BZERO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_EXPLICIT_BZERO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFSL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FFSL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FFSL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FFSL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFSLL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FFSLL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FFSLL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FFSLL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MEMCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMMEM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MEMMEM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MEMMEM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MEMMEM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MEMPCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MEMRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MEMRCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MEMRCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MEMSET_EXPLICIT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MEMSET_EXPLICIT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MEMSET_EXPLICIT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MEMSET_EXPLICIT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RAWMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RAWMEMCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STPCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STPCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STPNCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STPNCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STPNCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRCHRNUL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRCHRNUL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRCHRNUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRCHRNUL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRDUP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRDUP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRNCAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRNCAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRNCAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNDUP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRNDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRNDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRNDUP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRNLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRPBRK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRPBRK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSEP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRSEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRSEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRSEP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSTR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRSTR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRCASESTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRCASESTR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRTOK_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRTOK_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSNLEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSNLEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSRCHR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSRCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSRCHR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSSTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSSTR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSCASECMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSNCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSNCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSNCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSNCASECMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSPCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSPCASECMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSPCASECMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSPCASECMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSCASESTR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSCASESTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSCASESTR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSCSPN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSCSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSCSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSCSPN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSPBRK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSPBRK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSPBRK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSPN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSSPN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSSPN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSSPN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSSEP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSSEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSSEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSSEP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MBSTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MBSTOK_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MBSTOK_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MBSTOK_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERROR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRERROR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRERROR_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRERROR_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRERROR_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRERRORNAME_NP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRERRORNAME_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRERRORNAME_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRERRORNAME_NP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGABBREV_NP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGABBREV_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGABBREV_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGABBREV_NP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGDESCR_NP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGDESCR_NP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGDESCR_NP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGDESCR_NP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRSIGNAL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRSIGNAL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRSIGNAL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRSIGNAL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRVERSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRVERSCMP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRVERSCMP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRVERSCMP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_MEMCCPY], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_MEMCCPY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_MEMCCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_MEMCCPY$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_STRDUP], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_STRDUP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_STRDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_STRDUP$]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbslen]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbslen]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbslen]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBSLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBSLEN$]) -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([mbsstr]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbsstr]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbsstr]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbsstr]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBSLEN], [/* Define to 1 when the gnulib module mbslen should be tested. */ +@%:@undef GNULIB_TEST_MBSLEN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBSSTR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBSSTR$]) -m4trace:configure.ac:114: -1- gl_MBSTATE_T_BROKEN -m4trace:configure.ac:114: -1- gl_MUSL_LIBC -m4trace:configure.ac:114: -1- gl_WCHAR_MODULE_INDICATOR([mbszero]) -m4trace:configure.ac:114: -1- gl_WCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mbszero]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mbszero]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mbszero]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBSSTR], [/* Define to 1 when the gnulib module mbsstr should be tested. */ +@%:@undef GNULIB_TEST_MBSSTR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MBSZERO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MBSZERO$]) -m4trace:configure.ac:114: -1- gl_MBITER -m4trace:configure.ac:114: -1- gl_MBITER -m4trace:configure.ac:114: -1- gl_FUNC_MEMCHR -m4trace:configure.ac:114: -1- gl_FUNC_MMAP_ANON +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MBSZERO], [/* Define to 1 when the gnulib module mbszero should be tested. */ +@%:@undef GNULIB_TEST_MBSZERO]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([MAP_ANONYMOUS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^MAP_ANONYMOUS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([MAP_ANONYMOUS], [/* Define to a substitute value for mmap()\'s MAP_ANONYMOUS flag. */ +@%:@undef MAP_ANONYMOUS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MAP_ANONYMOUS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MAP_ANONYMOUS$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_mman_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/mman.h ]AS_TR_SH([sys/mman.h]) AS_TR_CPP([HAVE_sys/mman.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_mprotect], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" mprotect ]AS_TR_CPP([HAVE_mprotect])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MEMCHR], [test $REPLACE_MEMCHR = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MAP_ANONYMOUS], [/* Define to 1 if mmap()\'s MAP_ANONYMOUS flag is available after including + config.h and . */ +@%:@undef HAVE_MAP_ANONYMOUS]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_MMAN_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_MMAN_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MPROTECT], [/* Define to 1 if you have the \'mprotect\' function. */ +@%:@undef HAVE_MPROTECT]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MEMCHR], [test $REPLACE_MEMCHR = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMCHR_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMCHR_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMCHR_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMCHR_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMCHR_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMCHR_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMCHR_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMCHR_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MEMCHR], [ - gl_PREREQ_MEMCHR - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_MEMCHR +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MEMCHR]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_BP_SYM_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_BP_SYM_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_BP_SYM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_BP_SYM_H$]) -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([memchr]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([memchr]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[memchr]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([memchr]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MEMCHR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MEMCHR$]) -m4trace:configure.ac:114: -1- gl_FUNC_MEMMOVE +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MEMCHR], [/* Define to 1 when the gnulib module memchr should be tested. */ +@%:@undef GNULIB_TEST_MEMCHR]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MEMMOVE], [/* Define to 1 if you have the \'memmove\' function. */ +@%:@undef HAVE_MEMMOVE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MEMMOVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MEMMOVE$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MEMMOVE], [test $ac_cv_func_memmove = no]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MEMMOVE], [test $ac_cv_func_memmove = no]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMMOVE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMMOVE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMMOVE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMMOVE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMMOVE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMMOVE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMMOVE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMMOVE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MEMMOVE], [ - gl_PREREQ_MEMMOVE - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_MEMMOVE -m4trace:configure.ac:114: -1- gl_FUNC_MEMPCPY -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([mempcpy], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([mempcpy], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([mempcpy]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([mempcpy], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([mempcpy]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([mempcpy]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MEMMOVE]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MEMMOVE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MEMPCPY$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MEMPCPY], [test $HAVE_MEMPCPY = 0 || test $REPLACE_MEMPCPY = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MEMPCPY], [/* Define to 1 if you have the `mempcpy\' function. */ +@%:@undef HAVE_MEMPCPY]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MEMPCPY], [test $HAVE_MEMPCPY = 0 || test $REPLACE_MEMPCPY = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMPCPY_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMPCPY_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMPCPY_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MEMPCPY_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MEMPCPY_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MEMPCPY_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMPCPY_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MEMPCPY_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_MEMPCPY], [ - gl_PREREQ_MEMPCPY - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_MEMPCPY -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([mempcpy]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([mempcpy]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[mempcpy]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([mempcpy]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_MEMPCPY]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_MEMPCPY$]) -m4trace:configure.ac:114: -1- gl_MINMAX -m4trace:configure.ac:114: -1- gl_PREREQ_MINMAX -m4trace:configure.ac:114: -1- gl_MINMAX_IN_HEADER([limits.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_MEMPCPY], [/* Define to 1 when the gnulib module mempcpy should be tested. */ +@%:@undef GNULIB_TEST_MEMPCPY]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MINMAX_IN_LIMITS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MINMAX_IN_LIMITS_H$]) -m4trace:configure.ac:114: -1- gl_MINMAX_IN_HEADER([sys/param.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MINMAX_IN_LIMITS_H], [/* Define to 1 if defines the MIN and MAX macros. */ +@%:@undef HAVE_MINMAX_IN_LIMITS_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MINMAX_IN_SYS_PARAM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MINMAX_IN_SYS_PARAM_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MSVC_INVAL], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MINMAX_IN_SYS_PARAM_H], [/* Define to 1 if defines the MIN and MAX macros. */ +@%:@undef HAVE_MINMAX_IN_SYS_PARAM_H]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MSVC_INVAL], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MSVC_INVAL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MSVC_INVAL_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MSVC_INVAL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MSVC_INVAL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MSVC_INVAL_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MSVC_INVAL_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MSVC_INVAL_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MSVC_INVAL_FALSE]) -m4trace:configure.ac:114: -1- gl_MSVC_NOTHROW -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_MSVC_NOTHROW], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_MSVC_NOTHROW], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MSVC_NOTHROW_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MSVC_NOTHROW_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MSVC_NOTHROW_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_MSVC_NOTHROW_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_MSVC_NOTHROW_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_MSVC_NOTHROW_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MSVC_NOTHROW_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_MSVC_NOTHROW_FALSE]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([msvc-nothrow]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_MSVC_NOTHROW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_MSVC_NOTHROW$]) -m4trace:configure.ac:114: -1- gl_MULTIARCH -m4trace:configure.ac:114: -1- gl_FUNC_OPEN -m4trace:configure.ac:114: -1- gl_PREPROC_O_CLOEXEC -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_lstat], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" lstat ]AS_TR_CPP([HAVE_lstat])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_OPEN_TRAILING_SLASH_BUG -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_lstat], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" lstat ]AS_TR_CPP([HAVE_lstat])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- GL_MDA_DEFINES +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_MSVC_NOTHROW], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module msvc-nothrow shall be considered present. */ +@%:@undef GNULIB_MSVC_NOTHROW]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LSTAT], [/* Define to 1 if you have the \'lstat\' function. */ +@%:@undef HAVE_LSTAT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LSTAT], [/* Define to 1 if you have the \'lstat\' function. */ +@%:@undef HAVE_LSTAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([OPEN_TRAILING_SLASH_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^OPEN_TRAILING_SLASH_BUG$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_OPEN], [test $REPLACE_OPEN = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([OPEN_TRAILING_SLASH_BUG], [/* Define to 1 if open() fails to recognize a trailing slash. */ +@%:@undef OPEN_TRAILING_SLASH_BUG]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_OPEN], [test $REPLACE_OPEN = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_OPEN_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_OPEN_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_OPEN_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_OPEN_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_OPEN_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_OPEN_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_OPEN_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_OPEN_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_OPEN], [ - gl_PREREQ_OPEN - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_OPEN -m4trace:configure.ac:114: -1- gl_PROMOTED_TYPE_MODE_T +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_OPEN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([PROMOTED_MODE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PROMOTED_MODE_T$]) -m4trace:configure.ac:114: -1- gl_FCNTL_MODULE_INDICATOR([open]) -m4trace:configure.ac:114: -1- gl_FCNTL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([open]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[open]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([open]) +m4trace:configure.ac:114: -1- AH_OUTPUT([PROMOTED_MODE_T], [/* Define to the type that is the result of default argument promotions of + type mode_t. */ +@%:@undef PROMOTED_MODE_T]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_OPEN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_OPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_OPEN$]) -m4trace:configure.ac:114: -1- gl_PATHMAX -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_param_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/param.h ]AS_TR_SH([sys/param.h]) AS_TR_CPP([HAVE_sys/param.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_OPEN], [/* Define to 1 when the gnulib module open should be tested. */ +@%:@undef GNULIB_TEST_OPEN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_PARAM_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_PARAM_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PROGRAM_INVOCATION_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_NAME$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PROGRAM_INVOCATION_NAME], [/* Define to 1 if you have the declaration of \'program_invocation_name\', and + to 0 if you don\'t. */ +@%:@undef HAVE_DECL_PROGRAM_INVOCATION_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME], [/* Define to 1 if you have the declaration of \'program_invocation_short_name\', + and to 0 if you don\'t. */ +@%:@undef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME]) m4trace:configure.ac:114: -1- AM_XGETTEXT_OPTION([--keyword='proper_name:1,\"This is a proper name. See the gettext manual, section Names.\"']) m4trace:configure.ac:114: -1- AM_XGETTEXT_OPTION([--keyword='proper_name_utf8:1,\"This is a proper name. See the gettext manual, section Names.\"']) -m4trace:configure.ac:114: -1- gl_FUNC_RAISE -m4trace:configure.ac:114: -1- gl_SIGNAL_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_POSIX_SIGNALBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_POSIX_SIGNALBLOCKING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_POSIX_SIGNALBLOCKING$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PTHREAD_SIGMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PTHREAD_SIGMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PTHREAD_SIGMASK$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RAISE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RAISE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RAISE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGSET_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGSET_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGSET_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGINFO_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGINFO_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGINFO_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGACTION]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGACTION]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGACTION$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRUCT_SIGACTION_SA_SIGACTION]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRUCT_SIGACTION_SA_SIGACTION]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_SIGACTION_SA_SIGACTION$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_TYPE_VOLATILE_SIG_ATOMIC_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_TYPE_VOLATILE_SIG_ATOMIC_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TYPE_VOLATILE_SIG_ATOMIC_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_SIGHANDLER_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_SIGHANDLER_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGHANDLER_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PTHREAD_SIGMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PTHREAD_SIGMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PTHREAD_SIGMASK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RAISE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RAISE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RAISE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_RAISE], [/* Define to 1 if you have the \'raise\' function. */ +@%:@undef HAVE_RAISE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_RAISE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RAISE$]) -m4trace:configure.ac:114: -1- gl_SIGNALBLOCKING -m4trace:configure.ac:114: -1- gl_CHECK_TYPE_SIGSET_T +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SIGSET_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SIGSET_T$]) -m4trace:configure.ac:114: -1- gl_SIGNAL_SIGPIPE -m4trace:configure.ac:114: -1- gl_SIGNAL_SIGPIPE_BODY -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_RAISE], [test $HAVE_RAISE = 0 || test $REPLACE_RAISE = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SIGSET_T], [/* Define to 1 if the system has the type \'sigset_t\'. */ +@%:@undef HAVE_SIGSET_T]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_RAISE], [test $HAVE_RAISE = 0 || test $REPLACE_RAISE = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_RAISE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_RAISE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_RAISE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_RAISE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_RAISE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_RAISE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_RAISE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_RAISE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_RAISE], [ - gl_PREREQ_RAISE - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_RAISE -m4trace:configure.ac:114: -1- gl_SIGNAL_MODULE_INDICATOR([raise]) -m4trace:configure.ac:114: -1- gl_SIGNAL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PTHREAD_SIGMASK]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_RAISE]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_RAISE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PTHREAD_SIGMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PTHREAD_SIGMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PTHREAD_SIGMASK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RAISE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RAISE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RAISE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RAISE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGNAL_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGNAL_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGNAL_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGPROCMASK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGPROCMASK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGPROCMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGPROCMASK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGACTION]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGACTION]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGACTION]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGACTION$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([raise]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[raise]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([raise]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_RAISE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_RAISE$]) -m4trace:configure.ac:114: -1- gl_FUNC_RAWMEMCHR +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_RAISE], [/* Define to 1 when the gnulib module raise should be tested. */ +@%:@undef GNULIB_TEST_RAISE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_RAWMEMCHR], [/* Define to 1 if you have the \'rawmemchr\' function. */ +@%:@undef HAVE_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_RAWMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RAWMEMCHR$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_RAWMEMCHR], [test $HAVE_RAWMEMCHR = 0]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_RAWMEMCHR], [test $HAVE_RAWMEMCHR = 0]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_RAWMEMCHR_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_RAWMEMCHR_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_RAWMEMCHR_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_RAWMEMCHR_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_RAWMEMCHR_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_RAWMEMCHR_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_RAWMEMCHR_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_RAWMEMCHR_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_RAWMEMCHR], [ - gl_PREREQ_RAWMEMCHR - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_RAWMEMCHR -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([rawmemchr]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([rawmemchr]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[rawmemchr]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([rawmemchr]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_RAWMEMCHR]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_RAWMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_RAWMEMCHR$]) -m4trace:configure.ac:114: -1- gl_FUNC_READLINK -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_readlink], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" readlink ]AS_TR_CPP([HAVE_readlink])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_RAWMEMCHR], [/* Define to 1 when the gnulib module rawmemchr should be tested. */ +@%:@undef GNULIB_TEST_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_READLINK], [/* Define to 1 if you have the \'readlink\' function. */ +@%:@undef HAVE_READLINK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([READLINK_TRAILING_SLASH_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^READLINK_TRAILING_SLASH_BUG$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([READLINK_TRAILING_SLASH_BUG], [/* Define to 1 if readlink fails to recognize a trailing slash. */ +@%:@undef READLINK_TRAILING_SLASH_BUG]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([READLINK_TRUNCATE_BUG]) m4trace:configure.ac:114: -1- m4_pattern_allow([^READLINK_TRUNCATE_BUG$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_READLINK], [test $HAVE_READLINK = 0 || test $REPLACE_READLINK = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([READLINK_TRUNCATE_BUG], [/* Define to 1 if readlink sets errno instead of truncating a too-long link. + */ +@%:@undef READLINK_TRUNCATE_BUG]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_READLINK], [test $HAVE_READLINK = 0 || test $REPLACE_READLINK = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_READLINK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_READLINK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_READLINK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_READLINK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_READLINK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_READLINK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_READLINK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_READLINK_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_READLINK], [ - gl_PREREQ_READLINK - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_READLINK -m4trace:configure.ac:114: -1- gl_UNISTD_MODULE_INDICATOR([readlink]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([readlink]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[readlink]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([readlink]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_READLINK]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_READLINK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_READLINK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_READLINK$]) -m4trace:configure.ac:114: -1- gl_FUNC_REALLOC_GNU -m4trace:configure.ac:114: -1- gl_FUNC_REALLOC_POSIX -m4trace:configure.ac:114: -1- _AC_FUNC_REALLOC_IF([], [REPLACE_REALLOC_FOR_REALLOC_GNU=1]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([realloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([realloc-gnu]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([realloc-gnu]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[realloc-gnu]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([realloc-gnu]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_READLINK], [/* Define to 1 when the gnulib module readlink should be tested. */ +@%:@undef GNULIB_TEST_READLINK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_REALLOC_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_REALLOC_GNU$]) -m4trace:configure.ac:114: -1- gl_FUNC_REALLOC_POSIX -m4trace:configure.ac:114: -1- gl_LIBSOURCES([realloc.c]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([realloc-posix]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([realloc-posix]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[realloc-posix]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([realloc-posix]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_REALLOC_GNU], [/* Define to 1 when the gnulib module realloc-gnu should be tested. */ +@%:@undef GNULIB_TEST_REALLOC_GNU]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_REALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_REALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_FUNC_REALLOCARRAY -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([reallocarray], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([reallocarray], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([reallocarray]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([reallocarray], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([reallocarray]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([reallocarray]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_REALLOC_POSIX], [/* Define to 1 when the gnulib module realloc-posix should be tested. */ +@%:@undef GNULIB_TEST_REALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_REALLOCARRAY$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_REALLOCARRAY], [test $HAVE_REALLOCARRAY = 0 || test $REPLACE_REALLOCARRAY = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_REALLOCARRAY], [/* Define to 1 if you have the `reallocarray\' function. */ +@%:@undef HAVE_REALLOCARRAY]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_REALLOCARRAY], [test $HAVE_REALLOCARRAY = 0 || test $REPLACE_REALLOCARRAY = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_REALLOCARRAY_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_REALLOCARRAY_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_REALLOCARRAY_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_REALLOCARRAY_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_REALLOCARRAY_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_REALLOCARRAY_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_REALLOCARRAY_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_REALLOCARRAY_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_REALLOCARRAY], [ - gl_PREREQ_REALLOCARRAY - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_REALLOCARRAY -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([reallocarray]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_REALLOCARRAY]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_REALLOCARRAY$]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([reallocarray]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([reallocarray]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[reallocarray]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([reallocarray]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_REALLOCARRAY], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module reallocarray shall be considered present. */ +@%:@undef GNULIB_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_REALLOCARRAY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_REALLOCARRAY$]) -m4trace:configure.ac:114: -1- gl_RELOCATABLE([$gl_source_base]) -m4trace:configure.ac:114: -1- gl_RELOCATABLE_BODY -m4trace:configure.ac:114: -1- AC_LIB_LIBPATH -m4trace:configure.ac:114: -1- gl_RELOCATABLE_LIBRARY_BODY -m4trace:configure.ac:114: -1- gl_RELOCATABLE_NOP +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_REALLOCARRAY], [/* Define to 1 when the gnulib module reallocarray should be tested. */ +@%:@undef GNULIB_TEST_REALLOCARRAY]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([INSTALLPREFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INSTALLPREFIX$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([INSTALLPREFIX], [/* Define to the value of @S|@{prefix}, as a string. */ +@%:@undef INSTALLPREFIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([ENABLE_RELOCATABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ENABLE_RELOCATABLE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([ENABLE_RELOCATABLE], [/* Define to 1 if the package shall run at any location in the file system. */ +@%:@undef ENABLE_RELOCATABLE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MACH_O_DYLD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_MACH_O_DYLD_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MACH_O_DYLD_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MACH_O_DYLD_H$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE__NSGETEXECUTABLEPATH], [/* Define to 1 if you have the \'_NSGetExecutablePath\' function. */ +@%:@undef HAVE__NSGETEXECUTABLEPATH]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE__NSGETEXECUTABLEPATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE__NSGETEXECUTABLEPATH$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_COPY_FILE_RANGE], [/* Define to 1 if you have the \'copy_file_range\' function. */ +@%:@undef HAVE_COPY_FILE_RANGE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_COPY_FILE_RANGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_COPY_FILE_RANGE$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_LDFLAGS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_LDFLAGS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_LDFLAGS$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_LDFLAGS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_LDFLAGS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_LDFLAGS$]) +m4trace:configure.ac:114: -1- AC_SUBST([INSTALL_PROGRAM_ENV]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([INSTALL_PROGRAM_ENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^INSTALL_PROGRAM_ENV$]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([RELOCATABLE_VIA_LD], [test $is_noop = yes || test $use_elf_origin_trick = yes || test $use_macos_tools = yes]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_VIA_LD_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_VIA_LD_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_VIA_LD_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_VIA_LD_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_VIA_LD_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_VIA_LD_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([RELOCATABLE_VIA_LD_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([RELOCATABLE_VIA_LD_FALSE]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([RELOCATABLE_VIA_WRAPPER], [test $use_wrapper = yes]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_VIA_WRAPPER_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_VIA_WRAPPER_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_VIA_WRAPPER_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_VIA_WRAPPER_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_VIA_WRAPPER_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_VIA_WRAPPER_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([RELOCATABLE_VIA_WRAPPER_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([RELOCATABLE_VIA_WRAPPER_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_LIBRARY_PATH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_LIBRARY_PATH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_LIBRARY_PATH$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_CONFIG_H_DIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_CONFIG_H_DIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_CONFIG_H_DIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_SRC_DIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_SRC_DIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_SRC_DIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_BUILD_DIR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_BUILD_DIR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_BUILD_DIR$]) +m4trace:configure.ac:114: -1- AC_SUBST([RELOCATABLE_STRIP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([RELOCATABLE_STRIP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^RELOCATABLE_STRIP$]) -m4trace:configure.ac:114: -1- gl_RELOCATABLE_LIBRARY -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_PROGRELOC], [test $RELOCATABLE = yes]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_PROGRELOC], [test $RELOCATABLE = yes]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_PROGRELOC_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_PROGRELOC_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_PROGRELOC_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_PROGRELOC_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_PROGRELOC_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_PROGRELOC_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_PROGRELOC_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_PROGRELOC_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_PROGRELOC], [ - AC_LIBOBJ([relocatable]) - ]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([relocatable.c]) -m4trace:configure.ac:114: -1- gl_FUNC_READLINK_SEPARATE -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_readlink], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" readlink ]AS_TR_CPP([HAVE_readlink])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_PREREQ_READLINK -m4trace:configure.ac:114: -1- gl_CANONICALIZE_LGPL_SEPARATE -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_canonicalize_file_name], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" canonicalize_file_name ]AS_TR_CPP([HAVE_canonicalize_file_name])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([faccessat], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([faccessat], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([faccessat]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([faccessat], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([faccessat]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([faccessat]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_PROGRELOC]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_PROGRELOC]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_READLINK], [/* Define to 1 if you have the \'readlink\' function. */ +@%:@undef HAVE_READLINK]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_CANONICALIZE_FILE_NAME], [/* Define to 1 if you have the \'canonicalize_file_name\' function. */ +@%:@undef HAVE_CANONICALIZE_FILE_NAME]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FACCESSAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FACCESSAT$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FACCESSAT], [/* Define to 1 if you have the `faccessat\' function. */ +@%:@undef HAVE_FACCESSAT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_GETCWD], [/* Define to 1 if you have the \'getcwd\' function. */ +@%:@undef HAVE_GETCWD]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_GETCWD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_GETCWD$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_param_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/param.h ]AS_TR_SH([sys/param.h]) AS_TR_CPP([HAVE_sys/param.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_FUNC_MALLOC_POSIX +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_PARAM_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_PARAM_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MALLOC_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MALLOC_POSIX$]) -m4trace:configure.ac:114: -1- gl_FUNC_REALLOC_POSIX -m4trace:configure.ac:114: -1- gl_FUNC_FREE +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MALLOC_POSIX], [/* Define if malloc, realloc, and calloc set errno on allocation failure. */ +@%:@undef HAVE_MALLOC_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_FREE_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FREE_POSIX$]) -m4trace:configure.ac:114: -1- gl_FUNC_MEMPCPY -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([mempcpy], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([mempcpy], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([mempcpy]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([mempcpy], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([mempcpy]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([mempcpy]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FREE_POSIX], [/* Define if the \'free\' function is guaranteed to preserve errno. */ +@%:@undef HAVE_FREE_POSIX]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_MEMPCPY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_MEMPCPY$]) -m4trace:configure.ac:114: -1- gl_FUNC_RAWMEMCHR +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_MEMPCPY], [/* Define to 1 if you have the `mempcpy\' function. */ +@%:@undef HAVE_MEMPCPY]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_RAWMEMCHR], [/* Define to 1 if you have the \'rawmemchr\' function. */ +@%:@undef HAVE_RAWMEMCHR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_RAWMEMCHR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RAWMEMCHR$]) -m4trace:configure.ac:114: -1- gl_MALLOCA -m4trace:configure.ac:114: -1- gl_RELOCATABLE_LIBRARY -m4trace:configure.ac:114: -1- gl_FUNC_SETENV_SEPARATE -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_setenv], [_AC_CHECK_DECLS([setenv])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_SETENV]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_SETENV$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_setenv], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" setenv ]AS_TR_CPP([HAVE_setenv])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_PREREQ_SETENV -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_unistd_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" unistd.h ]AS_TR_SH([unistd.h]) AS_TR_CPP([HAVE_unistd.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_SETENV], [/* Define to 1 if you have the declaration of \'setenv\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_SETENV]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SETENV], [/* Define to 1 if you have the \'setenv\' function. */ +@%:@undef HAVE_SETENV]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SEARCH_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SEARCH_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SEARCH_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SEARCH_H$]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_ANDROID([tsearch], [[#include ]]) -m4trace:configure.ac:114: -1- gl_SILENT([ - case "$host_os" in - gl_CHECK_FUNCS_CASE_FOR_ANDROID([tsearch], [[#include ]]) - gl_CHECK_FUNCS_DEFAULT_CASE([tsearch]) - esac - ]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_CASE_FOR_ANDROID([tsearch], [[#include ]]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_DEFAULT_CASE([tsearch]) -m4trace:configure.ac:114: -1- gl_CHECK_FUNCS_SET_RESULTS([tsearch]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_TSEARCH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TSEARCH$]) -m4trace:configure.ac:114: -1- gl_FUNC_SETLOCALE +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_TSEARCH], [/* Define to 1 if you have the `tsearch\' function. */ +@%:@undef HAVE_TSEARCH]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([NEED_SETLOCALE_IMPROVED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEED_SETLOCALE_IMPROVED$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([NEED_SETLOCALE_IMPROVED], [/* Define to 1 to enable general improvements of setlocale. */ +@%:@undef NEED_SETLOCALE_IMPROVED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([NEED_SETLOCALE_MTSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEED_SETLOCALE_MTSAFE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([NEED_SETLOCALE_MTSAFE], [/* Define to 1 to enable a multithread-safety fix of setlocale. */ +@%:@undef NEED_SETLOCALE_MTSAFE]) +m4trace:configure.ac:114: -1- AC_SUBST([SETLOCALE_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SETLOCALE_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SETLOCALE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SETLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SETLOCALE$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE], [test $REPLACE_SETLOCALE = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_SETLOCALE], [test $REPLACE_SETLOCALE = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SETLOCALE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SETLOCALE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SETLOCALE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SETLOCALE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SETLOCALE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SETLOCALE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SETLOCALE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SETLOCALE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_SETLOCALE], [ - gl_PREREQ_SETLOCALE - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_SETLOCALE -m4trace:configure.ac:114: -1- gl_LOCALE_MODULE_INDICATOR([setlocale]) -m4trace:configure.ac:114: -1- gl_LOCALE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([setlocale]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[setlocale]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([setlocale]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_SETLOCALE]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_SETLOCALE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_SETLOCALE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_SETLOCALE$]) -m4trace:configure.ac:114: -1- gl_FUNC_SETLOCALE_NULL -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_threads_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" threads.h ]AS_TR_SH([threads.h]) AS_TR_CPP([HAVE_threads.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_SETLOCALE], [/* Define to 1 when the gnulib module setlocale should be tested. */ +@%:@undef GNULIB_TEST_SETLOCALE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_THREADS_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_THREADS_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([SETLOCALE_NULL_ALL_MTSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_ALL_MTSAFE$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([SETLOCALE_NULL_ALL_MTSAFE], [/* Define to 1 if setlocale (LC_ALL, NULL) is multithread-safe. */ +@%:@undef SETLOCALE_NULL_ALL_MTSAFE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([SETLOCALE_NULL_ONE_MTSAFE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_ONE_MTSAFE$]) -m4trace:configure.ac:114: -1- gl_WEAK_SYMBOLS +m4trace:configure.ac:114: -1- AH_OUTPUT([SETLOCALE_NULL_ONE_MTSAFE], [/* Define to 1 if setlocale (category, NULL) is multithread-safe. */ +@%:@undef SETLOCALE_NULL_ONE_MTSAFE]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WEAK_SYMBOLS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WEAK_SYMBOLS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WEAK_SYMBOLS], [/* Define to 1 if the compiler and linker support weak declarations of + symbols. */ +@%:@undef HAVE_WEAK_SYMBOLS]) +m4trace:configure.ac:114: -1- AC_SUBST([SETLOCALE_NULL_LIB]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SETLOCALE_NULL_LIB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SETLOCALE_NULL_LIB$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIB_SETLOCALE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIB_SETLOCALE_NULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIB_SETLOCALE_NULL$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE_LOCK], [test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_SETLOCALE_LOCK], [test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SETLOCALE_LOCK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SETLOCALE_LOCK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SETLOCALE_LOCK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SETLOCALE_LOCK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SETLOCALE_LOCK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SETLOCALE_LOCK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SETLOCALE_LOCK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SETLOCALE_LOCK_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_SETLOCALE_LOCK], [ - gl_PREREQ_SETLOCALE_LOCK - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_SETLOCALE_LOCK -m4trace:configure.ac:114: -1- gl_VISIBILITY +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_SETLOCALE_LOCK]) +m4trace:configure.ac:114: -1- AC_SUBST([CFLAG_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([CFLAG_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^CFLAG_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_VISIBILITY]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VISIBILITY$]) -m4trace:configure.ac:114: -1- gl_LOCALE_MODULE_INDICATOR([setlocale_null]) -m4trace:configure.ac:114: -1- gl_LOCALE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([setlocale_null]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[setlocale_null]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([setlocale_null]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_VISIBILITY], [/* Define to 1 or 0, depending whether the compiler supports simple visibility + declarations. */ +@%:@undef HAVE_VISIBILITY]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_SETLOCALE_LOCK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_SETLOCALE_NULL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_SETLOCALE_NULL$]) -m4trace:configure.ac:114: -1- gl_SIGNAL_H -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([signal.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([signal.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([signal.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_SETLOCALE_NULL], [/* Define to 1 when the gnulib module setlocale_null should be tested. */ +@%:@undef GNULIB_TEST_SETLOCALE_NULL]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_SIGNAL_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_SIGNAL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_SIGNAL_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_SIGNAL_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_SIGNAL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_SIGNAL_H$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([uid_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^uid_t$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([uid_t], [/* Define as \'int\' if doesn\'t define. */ +@%:@undef uid_t]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([gid_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^gid_t$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [pthread_sigmask sigaction - sigaddset sigdelset sigemptyset sigfillset sigismember - sigpending sigprocmask]) -m4trace:configure.ac:114: -1- gl_SIGNAL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_SIGNAL_SIGPIPE -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([sigpipe]) +m4trace:configure.ac:114: -1- AH_OUTPUT([gid_t], [/* Define as \'int\' if doesn\'t define. */ +@%:@undef gid_t]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_SIGNAL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE], [1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_SIGPIPE], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module sigpipe shall be considered present. */ +@%:@undef GNULIB_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SIGNAL_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SIGNAL_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SIGNAL_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_DPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_DPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_DPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_DPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FCLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FCLOSE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FDOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FDOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FDOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FDOPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FFLUSH]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FFLUSH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FFLUSH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FFLUSH$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FGETC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FGETC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FGETC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FGETC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FGETS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FGETS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FGETS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FGETS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FOPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FOPEN_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FOPEN_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FOPEN_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FOPEN_GNU$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FPRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FPRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPURGE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FPURGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FPURGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FPURGE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPUTC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FPUTC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FPUTC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FPUTC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FPUTS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FPUTS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FPUTS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FPUTS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREAD]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FREAD]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FREAD$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FREOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FREOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FREOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FREOPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSEEK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSEEK$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FSEEKO]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FSEEKO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FSEEKO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FSEEKO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTELL]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FTELL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FTELL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FTELL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FTELLO]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FTELLO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FTELLO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FTELLO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_FWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_FWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_FWRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_FWRITE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETCHAR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETCHAR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETCHAR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETCHAR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETDELIM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETDELIM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETDELIM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETDELIM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_GETLINE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_GETLINE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_GETLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_GETLINE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OBSTACK_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_OBSTACK_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_OBSTACK_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_OBSTACK_PRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OBSTACK_PRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_OBSTACK_PRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_OBSTACK_PRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_OBSTACK_PRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PCLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PCLOSE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PERROR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PERROR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_POPEN]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_POPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_POPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_POPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTC]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PUTC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PUTC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PUTC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTCHAR]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PUTCHAR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PUTCHAR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PUTCHAR$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_PUTS]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_PUTS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_PUTS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_PUTS$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_REMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_REMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_REMOVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_REMOVE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RENAME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RENAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RENAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RENAME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_RENAMEAT]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_RENAMEAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_RENAMEAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_RENAMEAT$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SCANF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SCANF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SNPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_SPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_SPRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_SPRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STDIO_H_NONBLOCKING]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STDIO_H_NONBLOCKING]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STDIO_H_NONBLOCKING$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STDIO_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STDIO_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STDIO_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TMPFILE]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TMPFILE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TMPFILE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TMPFILE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VASPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VASPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VASPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VASPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VFSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VFSCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VFSCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VSCANF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VSCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VSCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VDPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VDPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VDPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VDPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VFPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VFPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VFPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VFPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VFPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VFPRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VFPRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VPRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VPRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VSNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VSNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VSNPRINTF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_VSPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_VSPRINTF_POSIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_VSPRINTF_POSIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_VSPRINTF_POSIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FCLOSEALL], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_FCLOSEALL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_FCLOSEALL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_FCLOSEALL$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FDOPEN], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_FDOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_FDOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_FDOPEN$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_FILENO], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_FILENO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_FILENO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_FILENO$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_GETW], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_GETW]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_GETW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_GETW$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_PUTW], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_PUTW]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_PUTW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_PUTW$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_TEMPNAM], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_TEMPNAM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_TEMPNAM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_TEMPNAM$]) -m4trace:configure.ac:114: -1- gl_STDIO_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FCLOSEALL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FCLOSEALL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FCLOSEALL$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FPURGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FPURGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FPURGE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FSEEKO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FSEEKO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FSEEKO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_FTELLO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_FTELLO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FTELLO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETDELIM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETDELIM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETDELIM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETLINE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETLINE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_GETW]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_GETW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETW$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_OBSTACK_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_OBSTACK_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_OBSTACK_PRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_PUTW]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_PUTW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PUTW$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_SNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_SNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_SNPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_VSNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_VSNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_VSNPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FSEEKO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FSEEKO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FSEEKO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FTELLO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FTELLO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FTELLO$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_PCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_PCLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_PCLOSE$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_POPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_POPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_POPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_RENAMEAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_RENAMEAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_RENAMEAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_VASPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_VASPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VASPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_VDPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_VDPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_VDPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_DPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_DPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_DPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FCLOSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FCLOSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FCLOSE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FDOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FDOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FDOPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FFLUSH]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FFLUSH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FFLUSH$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FOPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FOPEN_FOR_FOPEN_GNU]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FOPEN_FOR_FOPEN_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FOPEN_FOR_FOPEN_GNU$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FPURGE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FPURGE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FPURGE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FREOPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FREOPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FREOPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FSEEK]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FSEEK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FSEEK$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FSEEKO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FSEEKO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FSEEKO$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FTELL]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FTELL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FTELL$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_FTELLO]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_FTELLO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FTELLO$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETDELIM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETDELIM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETDELIM$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GETLINE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GETLINE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GETLINE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_OBSTACK_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_OBSTACK_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_OBSTACK_PRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PERROR]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PERROR$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_POPEN]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_POPEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_POPEN$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_PRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_PRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_REMOVE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_REMOVE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_REMOVE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RENAME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RENAME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RENAME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_RENAMEAT]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_RENAMEAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_RENAMEAT$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SNPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_SPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_SPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_SPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STDIO_READ_FUNCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STDIO_READ_FUNCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STDIO_READ_FUNCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STDIO_WRITE_FUNCS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STDIO_WRITE_FUNCS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STDIO_WRITE_FUNCS$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TMPFILE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TMPFILE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TMPFILE$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VASPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VASPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VASPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VDPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VDPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VDPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VFPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VFPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VFPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VSNPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VSNPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VSNPRINTF$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_VSPRINTF]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_VSPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_VSPRINTF$]) -m4trace:configure.ac:114: -1- gl_ASM_SYMBOL_PREFIX -m4trace:configure.ac:114: -1- gl_C_ASM +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USER_LABEL_PREFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USER_LABEL_PREFIX$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USER_LABEL_PREFIX], [/* Define to the prefix of C symbols at the assembler and linker level, either + an underscore or empty. */ +@%:@undef USER_LABEL_PREFIX]) +m4trace:configure.ac:114: -1- AC_SUBST([ASM_SYMBOL_PREFIX]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([ASM_SYMBOL_PREFIX]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ASM_SYMBOL_PREFIX$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STDIO_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STDIO_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STDIO_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNISTD_H_SIGPIPE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNISTD_H_SIGPIPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNISTD_H_SIGPIPE$]) -m4trace:configure.ac:114: -1- gl_SIGNALBLOCKING -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_SIGPROCMASK], [test $HAVE_POSIX_SIGNALBLOCKING = 0]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_SIGPROCMASK], [test $HAVE_POSIX_SIGNALBLOCKING = 0]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SIGPROCMASK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SIGPROCMASK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SIGPROCMASK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_SIGPROCMASK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_SIGPROCMASK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_SIGPROCMASK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SIGPROCMASK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_SIGPROCMASK_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_SIGPROCMASK], [ - gl_PREREQ_SIGPROCMASK - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_SIGPROCMASK -m4trace:configure.ac:114: -1- gl_SIGNAL_MODULE_INDICATOR([sigprocmask]) -m4trace:configure.ac:114: -1- gl_SIGNAL_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([sigprocmask]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[sigprocmask]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([sigprocmask]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_SIGPROCMASK]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_SIGPROCMASK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_SIGPROCMASK]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_SIGPROCMASK$]) -m4trace:configure.ac:114: -1- gt_TYPE_SSIZE_T +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_SIGPROCMASK], [/* Define to 1 when the gnulib module sigprocmask should be tested. */ +@%:@undef GNULIB_TEST_SIGPROCMASK]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([ssize_t]) m4trace:configure.ac:114: -1- m4_pattern_allow([^ssize_t$]) -m4trace:configure.ac:114: -1- gl_FUNC_STAT -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_lstat], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" lstat ]AS_TR_CPP([HAVE_lstat])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([ssize_t], [/* Define as a signed type of the same size as size_t. */ +@%:@undef ssize_t]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_LSTAT], [/* Define to 1 if you have the \'lstat\' function. */ +@%:@undef HAVE_LSTAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([REPLACE_FUNC_STAT_FILE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_FUNC_STAT_FILE$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STAT], [test $REPLACE_STAT = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([REPLACE_FUNC_STAT_FILE], [/* Define to 1 if stat needs help when passed a file name with a trailing + slash */ +@%:@undef REPLACE_FUNC_STAT_FILE]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STAT], [test $REPLACE_STAT = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STAT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STAT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STAT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STAT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STAT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STAT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STAT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STAT_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_STAT], [ - case "$host_os" in - mingw* | windows*) - AC_LIBOBJ([stat-w32]) - ;; - esac - gl_PREREQ_STAT - ]) -m4trace:configure.ac:114: -1- gl_LIBSOURCES([stat-w32.c]) -m4trace:configure.ac:114: -1- gl_PREREQ_STAT -m4trace:configure.ac:114: -1- gl_SYS_STAT_MODULE_INDICATOR([stat]) -m4trace:configure.ac:114: -1- gl_SYS_STAT_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([stat]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[stat]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([stat]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_STAT]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_STAT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_STAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_STAT$]) -m4trace:configure.ac:114: -1- gl_STAT_TIME -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_time_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/time.h ]AS_TR_SH([sys/time.h]) AS_TR_CPP([HAVE_sys/time.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_STAT], [/* Define to 1 when the gnulib module stat should be tested. */ +@%:@undef GNULIB_TEST_STAT]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_TIME_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TIME_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC], [/* Define to 1 if \'st_atim.tv_nsec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC], [/* Define to 1 if the type of the st_atim member of a struct stat is struct + timespec. */ +@%:@undef TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC], [/* Define to 1 if \'st_atimespec.tv_nsec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_ATIMENSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_ATIMENSEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_ATIMENSEC], [/* Define to 1 if \'st_atimensec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_ATIMENSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC$]) -m4trace:configure.ac:114: -1- gl_STAT_BIRTHTIME -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_time_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/time.h ]AS_TR_SH([sys/time.h]) AS_TR_CPP([HAVE_sys/time.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC], [/* Define to 1 if \'st_atim.st__tim.tv_nsec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_TIME_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TIME_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC], [/* Define to 1 if \'st_birthtimespec.tv_nsec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC], [/* Define to 1 if \'st_birthtimensec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC$]) -m4trace:configure.ac:114: -1- gl_C_BOOL +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC], [/* Define to 1 if \'st_birthtim.tv_nsec\' is a member of \'struct stat\'. */ +@%:@undef HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_C_BOOL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C_BOOL$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_stdbool_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" stdbool.h ]AS_TR_SH([stdbool.h]) AS_TR_CPP([HAVE_stdbool.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_stdckdint_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" stdckdint.h ]AS_TR_SH([stdckdint.h]) AS_TR_CPP([HAVE_stdckdint.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([stdckdint.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_C_BOOL], [/* Define to 1 if bool, true and false work as per C2023. */ +@%:@undef HAVE_C_BOOL]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STDBOOL_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDBOOL_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([zzbool], [#ifndef HAVE_C_BOOL +# if !defined __cplusplus && !defined __bool_true_false_are_defined +# if HAVE_STDBOOL_H +# include +# else +# if defined __SUNPRO_C +# error " is not usable with this configuration. To make it usable, add -D_STDC_C99= to $CC." +# else +# error " does not exist on this platform. Use gnulib module \'stdbool-c99\' instead of gnulib module \'stdbool\'." +# endif +# endif +# endif +# if !true +# define true (!false) +# endif +#endif]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STDCKDINT_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_STDCKDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST([STDCKDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([STDCKDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STDCKDINT_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_STDCKDINT_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_STDCKDINT_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDCKDINT_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDCKDINT_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDCKDINT_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDCKDINT_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDCKDINT_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDCKDINT_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDCKDINT_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDCKDINT_H_FALSE]) -m4trace:configure.ac:114: -1- gl_STDDEF_H -m4trace:configure.ac:114: -1- gl_STDDEF_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([stddef.h]) +m4trace:configure.ac:114: -1- AC_SUBST([STDDEF_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([STDDEF_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STDDEF_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_STDDEF_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_STDDEF_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDDEF_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDDEF_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDDEF_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDDEF_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDDEF_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDDEF_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDDEF_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDDEF_H_FALSE]) -m4trace:configure.ac:114: -1- gl_STDINT_H -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([stdint.h]) +m4trace:configure.ac:114: -1- AC_SUBST([STDINT_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([STDINT_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^STDINT_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_STDINT_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_STDINT_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDINT_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDINT_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDINT_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_STDINT_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_STDINT_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_STDINT_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDINT_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_STDINT_H_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL_HEADER([limits.h]) +m4trace:configure.ac:114: -1- AC_SUBST([LIMITS_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIMITS_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIMITS_H$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_GENERATE_LIMITS_H], [$gl_generate_var]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_GENERATE_LIMITS_H], [$gl_generate_var]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_LIMITS_H_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_LIMITS_H_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_LIMITS_H_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GENERATE_LIMITS_H_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GENERATE_LIMITS_H_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GENERATE_LIMITS_H_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_LIMITS_H_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_GENERATE_LIMITS_H_FALSE]) -m4trace:configure.ac:114: -1- gl_STDIO_H -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([stdio.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([stdio.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([stdio.h]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_STDIO_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_STDIO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_STDIO_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_STDIO_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_STDIO_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_STDIO_H$]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU$]) -m4trace:configure.ac:114: -1- gl_MUSL_LIBC -m4trace:configure.ac:114: -1- gl_SIGNAL_SIGPIPE -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [dprintf fpurge fseeko ftello getdelim getline gets pclose popen - renameat snprintf tmpfile vdprintf vsnprintf]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fcloseall], [_AC_CHECK_DECLS([fcloseall])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU], [/* Define to 1 if printf and friends should be labeled with attribute + "__gnu_printf__" instead of "__printf__" */ +@%:@undef GNULIB_PRINTF_ATTRIBUTE_FLAVOR_GNU]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FCLOSEALL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FCLOSEALL$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_getw], [_AC_CHECK_DECLS([getw])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FCLOSEALL], [/* Define to 1 if you have the declaration of \'fcloseall\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_FCLOSEALL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_GETW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETW$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_putw], [_AC_CHECK_DECLS([putw])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_GETW], [/* Define to 1 if you have the declaration of \'getw\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_GETW]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PUTW]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PUTW$]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STDIO_READ], [test $REPLACE_STDIO_READ_FUNCS = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PUTW], [/* Define to 1 if you have the declaration of \'putw\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_PUTW]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STDIO_READ], [test $REPLACE_STDIO_READ_FUNCS = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STDIO_READ_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STDIO_READ_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STDIO_READ_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STDIO_READ_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STDIO_READ_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STDIO_READ_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STDIO_READ_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STDIO_READ_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STDIO_WRITE], [test $REPLACE_STDIO_WRITE_FUNCS = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STDIO_WRITE], [test $REPLACE_STDIO_WRITE_FUNCS = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STDIO_WRITE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STDIO_WRITE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STDIO_WRITE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STDIO_WRITE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STDIO_WRITE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STDIO_WRITE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STDIO_WRITE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STDIO_WRITE_FALSE]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fscanf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fscanf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fscanf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fscanf]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FSCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FSCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([fscanf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FSCANF], [/* Define to 1 when the gnulib module fscanf should be tested. */ +@%:@undef GNULIB_TEST_FSCANF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_FSCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_FSCANF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([scanf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([scanf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[scanf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([scanf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_FSCANF], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module fscanf shall be considered present. */ +@%:@undef GNULIB_FSCANF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_SCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_SCANF$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([scanf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_SCANF], [/* Define to 1 when the gnulib module scanf should be tested. */ +@%:@undef GNULIB_TEST_SCANF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_SCANF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_SCANF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fgetc]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fgetc]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fgetc]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fgetc]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_SCANF], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module scanf shall be considered present. */ +@%:@undef GNULIB_SCANF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FGETC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FGETC$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([getc]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([getc]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[getc]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([getc]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FGETC], [/* Define to 1 when the gnulib module fgetc should be tested. */ +@%:@undef GNULIB_TEST_FGETC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_GETC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_GETC$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([getchar]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([getchar]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[getchar]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([getchar]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_GETC], [/* Define to 1 when the gnulib module getc should be tested. */ +@%:@undef GNULIB_TEST_GETC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_GETCHAR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_GETCHAR$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fgets]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fgets]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fgets]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fgets]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_GETCHAR], [/* Define to 1 when the gnulib module getchar should be tested. */ +@%:@undef GNULIB_TEST_GETCHAR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FGETS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FGETS$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fread]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fread]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fread]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fread]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FGETS], [/* Define to 1 when the gnulib module fgets should be tested. */ +@%:@undef GNULIB_TEST_FGETS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FREAD$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fprintf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fprintf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fprintf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fprintf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FREAD], [/* Define to 1 when the gnulib module fread should be tested. */ +@%:@undef GNULIB_TEST_FREAD]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FPRINTF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([printf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([printf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[printf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([printf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FPRINTF], [/* Define to 1 when the gnulib module fprintf should be tested. */ +@%:@undef GNULIB_TEST_FPRINTF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_PRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_PRINTF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([vfprintf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([vfprintf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[vfprintf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([vfprintf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_PRINTF], [/* Define to 1 when the gnulib module printf should be tested. */ +@%:@undef GNULIB_TEST_PRINTF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_VFPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_VFPRINTF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([vprintf]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([vprintf]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[vprintf]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([vprintf]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_VFPRINTF], [/* Define to 1 when the gnulib module vfprintf should be tested. */ +@%:@undef GNULIB_TEST_VFPRINTF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_VPRINTF]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_VPRINTF$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fputc]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fputc]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fputc]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fputc]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_VPRINTF], [/* Define to 1 when the gnulib module vprintf should be tested. */ +@%:@undef GNULIB_TEST_VPRINTF]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FPUTC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FPUTC$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([putc]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([putc]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[putc]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([putc]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FPUTC], [/* Define to 1 when the gnulib module fputc should be tested. */ +@%:@undef GNULIB_TEST_FPUTC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_PUTC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_PUTC$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([putchar]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([putchar]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[putchar]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([putchar]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_PUTC], [/* Define to 1 when the gnulib module putc should be tested. */ +@%:@undef GNULIB_TEST_PUTC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_PUTCHAR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_PUTCHAR$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fputs]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fputs]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fputs]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fputs]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_PUTCHAR], [/* Define to 1 when the gnulib module putchar should be tested. */ +@%:@undef GNULIB_TEST_PUTCHAR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FPUTS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FPUTS$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([puts]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([puts]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[puts]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([puts]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FPUTS], [/* Define to 1 when the gnulib module fputs should be tested. */ +@%:@undef GNULIB_TEST_FPUTS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_PUTS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_PUTS$]) -m4trace:configure.ac:114: -1- gl_STDIO_MODULE_INDICATOR([fwrite]) -m4trace:configure.ac:114: -1- gl_STDIO_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([fwrite]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[fwrite]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([fwrite]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_PUTS], [/* Define to 1 when the gnulib module puts should be tested. */ +@%:@undef GNULIB_TEST_PUTS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_FWRITE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_FWRITE$]) -m4trace:configure.ac:114: -1- gl_STDLIB_H -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([stdlib.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([stdlib.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([stdlib.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_FWRITE], [/* Define to 1 when the gnulib module fwrite should be tested. */ +@%:@undef GNULIB_TEST_FWRITE]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_STDLIB_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_STDLIB_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_STDLIB_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_STDLIB_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_STDLIB_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_STDLIB_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include -#if HAVE_SYS_LOADAVG_H -/* OpenIndiana has a bug: must be included before - . */ -# include -# include -#endif -#if HAVE_RANDOM_H -# include -#endif - ]], [_Exit aligned_alloc atoll canonicalize_file_name free - getloadavg getprogname getsubopt grantpt - initstate initstate_r mbstowcs mbtowc mkdtemp mkostemp mkostemps mkstemp - mkstemps posix_memalign posix_openpt ptsname ptsname_r qsort_r - random random_r reallocarray realpath rpmatch secure_getenv setenv - setstate setstate_r srandom srandom_r - strtod strtol strtold strtoll strtoul strtoull unlockpt unsetenv]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_ecvt], [_AC_CHECK_DECLS([ecvt])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_ECVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_ECVT$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fcvt], [_AC_CHECK_DECLS([fcvt])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_ECVT], [/* Define to 1 if you have the declaration of \'ecvt\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_ECVT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FCVT$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_gcvt], [_AC_CHECK_DECLS([gcvt])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FCVT], [/* Define to 1 if you have the declaration of \'fcvt\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_FCVT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_GCVT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GCVT$]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_FUNC_STRERROR -m4trace:configure.ac:114: -1- gl_FUNC_STRERROR_0 +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_GCVT], [/* Define to 1 if you have the declaration of \'gcvt\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_GCVT]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([REPLACE_STRERROR_0]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRERROR_0$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STRERROR], [test $REPLACE_STRERROR = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([REPLACE_STRERROR_0], [/* Define to 1 if strerror(0) does not return a message implying success. */ +@%:@undef REPLACE_STRERROR_0]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STRERROR], [test $REPLACE_STRERROR = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRERROR_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRERROR_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRERROR_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRERROR_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRERROR_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRERROR_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRERROR_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRERROR_FALSE]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([strerror]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_STRERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_STRERROR$]) -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([strerror]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([strerror]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[strerror]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([strerror]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_STRERROR], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module strerror shall be considered present. */ +@%:@undef GNULIB_STRERROR]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_STRERROR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_STRERROR$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STRERROR_OVERRIDE], [test -n "$ERRNO_H" || test $REPLACE_STRERROR_0 = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_STRERROR], [/* Define to 1 when the gnulib module strerror should be tested. */ +@%:@undef GNULIB_TEST_STRERROR]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STRERROR_OVERRIDE], [test -n "$ERRNO_H" || test $REPLACE_STRERROR_0 = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRERROR_OVERRIDE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRERROR_OVERRIDE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRERROR_OVERRIDE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRERROR_OVERRIDE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRERROR_OVERRIDE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRERROR_OVERRIDE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRERROR_OVERRIDE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRERROR_OVERRIDE_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_STRERROR_OVERRIDE], [ - gl_PREREQ_SYS_H_WINSOCK2 - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_SYS_H_WINSOCK2 -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_socket_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/socket.h ]AS_TR_SH([sys/socket.h]) AS_TR_CPP([HAVE_sys/socket.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_STRERROR_OVERRIDE]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_SOCKET_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_SOCKET_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WINSOCK2_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WINSOCK2_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_WINSOCK2_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINSOCK2_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WINSOCK2_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WINSOCK2_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINSOCK2_H$]) -m4trace:configure.ac:114: -1- gl_STRING_H -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([string.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([string.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([string.h]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_STRERROR_OVERRIDE]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_STRING_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_STRING_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_STRING_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_STRING_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_STRING_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_STRING_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[#include - ]], [explicit_bzero ffsl ffsll memmem mempcpy memrchr memset_explicit - rawmemchr stpcpy stpncpy strchrnul - strdup strncat strndup strnlen strpbrk strsep strcasestr strtok_r - strerror_r strerrorname_np sigabbrev_np sigdescr_np strsignal strverscmp]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_FUNC_STRNLEN -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_strnlen], [_AC_CHECK_DECLS([strnlen])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_STRNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_STRNLEN$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STRNLEN], [test $HAVE_DECL_STRNLEN = 0 || test $REPLACE_STRNLEN = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_STRNLEN], [/* Define to 1 if you have the declaration of \'strnlen\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_STRNLEN]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STRNLEN], [test $HAVE_DECL_STRNLEN = 0 || test $REPLACE_STRNLEN = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRNLEN_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRNLEN_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRNLEN_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRNLEN_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRNLEN_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRNLEN_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRNLEN_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRNLEN_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_STRNLEN], [ - gl_PREREQ_STRNLEN - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_STRNLEN -m4trace:configure.ac:114: -1- gl_STRING_MODULE_INDICATOR([strnlen]) -m4trace:configure.ac:114: -1- gl_STRING_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([strnlen]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[strnlen]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([strnlen]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_STRNLEN]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_STRNLEN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_STRNLEN]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_STRNLEN$]) -m4trace:configure.ac:114: -1- gl_FUNC_STRTOUL +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_STRNLEN], [/* Define to 1 when the gnulib module strnlen should be tested. */ +@%:@undef GNULIB_TEST_STRNLEN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_STRTOUL], [/* Define to 1 if you have the \'strtoul\' function. */ +@%:@undef HAVE_STRTOUL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_STRTOUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRTOUL$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_STRTOUL], [test $HAVE_STRTOUL = 0 || test $REPLACE_STRTOUL = 1]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_STRTOUL], [test $HAVE_STRTOUL = 0 || test $REPLACE_STRTOUL = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRTOUL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRTOUL_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRTOUL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_STRTOUL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_STRTOUL_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_STRTOUL_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRTOUL_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_STRTOUL_FALSE]) -m4trace:configure.ac:114: -1- gl_STDLIB_MODULE_INDICATOR([strtoul]) -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([strtoul]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[strtoul]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([strtoul]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_STRTOUL]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_STRTOUL$]) -m4trace:configure.ac:114: -1- gl_SYS_STAT_H -m4trace:configure.ac:114: -1- gl_SYS_STAT_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_SYS_TYPES_H -m4trace:configure.ac:114: -1- gl_SYS_TYPES_H_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_STRTOUL], [/* Define to 1 when the gnulib module strtoul should be tested. */ +@%:@undef GNULIB_TEST_STRTOUL]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([_USE_STD_STAT]) m4trace:configure.ac:114: -1- m4_pattern_allow([^_USE_STD_STAT$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([sys/types.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([sys/types.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([sys/types.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([_USE_STD_STAT], [/* For standard stat data types on VMS. */ +@%:@undef _USE_STD_STAT]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_SYS_TYPES_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_SYS_TYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_SYS_TYPES_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_SYS_TYPES_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_SYS_TYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_SYS_TYPES_H$]) -m4trace:configure.ac:114: -1- gl_TYPE_OFF_T +m4trace:configure.ac:114: -1- AC_SUBST([WINDOWS_64_BIT_OFF_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WINDOWS_64_BIT_OFF_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WINDOWS_64_BIT_OFF_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([WINDOWS_STAT_INODES]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([WINDOWS_STAT_INODES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^WINDOWS_STAT_INODES$]) -m4trace:configure.ac:114: -1- gl_SYS_TYPES_H_REQUIRE_DEFAULTS +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_SINGLE_THREADED_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_SINGLE_THREADED_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SYS_SINGLE_THREADED_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_SYS_SINGLE_THREADED_H$]) -m4trace:configure.ac:114: -1- gl_TIME_H -m4trace:configure.ac:114: -1- gl_TIME_H_DEFAULTS +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_DECL_LOCALTIME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_DECL_LOCALTIME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_LOCALTIME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_NANOSLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_NANOSLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_NANOSLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_STRPTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_STRPTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_STRPTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_TIMEGM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_TIMEGM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TIMEGM$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_TIMESPEC_GET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_TIMESPEC_GET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TIMESPEC_GET$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_TIMESPEC_GETRES]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_TIMESPEC_GETRES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TIMESPEC_GETRES$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_TIMEZONE_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_TIMEZONE_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_TIMEZONE_T$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_CTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_CTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_CTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_GMTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_GMTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_GMTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LOCALTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LOCALTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LOCALTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_LOCALTIME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_LOCALTIME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_LOCALTIME_R$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_MKTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_MKTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_MKTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_NANOSLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_NANOSLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_NANOSLEEP$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_STRFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_STRFTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_STRFTIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TIME$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TIMEGM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TIMEGM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TIMEGM$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TIMESPEC_GET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TIMESPEC_GET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TIMESPEC_GET$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TIMESPEC_GETRES]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TIMESPEC_GETRES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TIMESPEC_GETRES$]) +m4trace:configure.ac:114: -1- AC_SUBST([REPLACE_TZSET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([REPLACE_TZSET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^REPLACE_TZSET$]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS([time.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([time.h], [assume]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([time.h]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_TIME_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_TIME_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_TIME_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_TIME_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_TIME_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_TIME_H$]) -m4trace:configure.ac:114: -1- gl_CHECK_TYPE_STRUCT_TIMESPEC -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_sys_time_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" sys/time.h ]AS_TR_SH([sys/time.h]) AS_TR_CPP([HAVE_sys/time.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_SYS_TIME_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_SYS_TIME_H]) +m4trace:configure.ac:114: -1- AC_SUBST([TIME_H_DEFINES_STRUCT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([TIME_H_DEFINES_STRUCT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^TIME_H_DEFINES_STRUCT_TIMESPEC$]) +m4trace:configure.ac:114: -1- AC_SUBST([SYS_TIME_H_DEFINES_STRUCT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([SYS_TIME_H_DEFINES_STRUCT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^SYS_TIME_H_DEFINES_STRUCT_TIMESPEC$]) +m4trace:configure.ac:114: -1- AC_SUBST([PTHREAD_H_DEFINES_STRUCT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([PTHREAD_H_DEFINES_STRUCT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^PTHREAD_H_DEFINES_STRUCT_TIMESPEC$]) +m4trace:configure.ac:114: -1- AC_SUBST([UNISTD_H_DEFINES_STRUCT_TIMESPEC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([UNISTD_H_DEFINES_STRUCT_TIMESPEC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^UNISTD_H_DEFINES_STRUCT_TIMESPEC$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[ -#include - ]], [ - asctime asctime_r ctime ctime_r gmtime_r localtime localtime_r mktime - nanosleep strftime strptime time timegm timespec_get timespec_getres tzset - ]) +m4trace:configure.ac:114: -1- AC_SUBST([TIME_H_DEFINES_TIME_UTC]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([TIME_H_DEFINES_TIME_UTC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^TIME_H_DEFINES_TIME_UTC$]) -m4trace:configure.ac:114: -1- gl_TIME_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_CTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_CTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_CTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_CTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MKTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MKTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MKTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MKTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_LOCALTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_LOCALTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_LOCALTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_LOCALTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_NANOSLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_NANOSLEEP]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_NANOSLEEP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_NANOSLEEP$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRFTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRFTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRFTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STRPTIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_STRPTIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_STRPTIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_STRPTIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIME]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIME]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIME$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMEGM]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIMEGM]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIMEGM]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIMEGM$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMESPEC_GET]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIMESPEC_GET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIMESPEC_GET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIMESPEC_GET$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIMESPEC_GETRES]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIMESPEC_GETRES]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIMESPEC_GETRES]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIMESPEC_GETRES$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME_R]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIME_R]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIME_R]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIME_R$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TIME_RZ]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TIME_RZ]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TIME_RZ]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TIME_RZ$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_TZSET]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_TZSET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_TZSET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_TZSET$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_MDA_TZSET], [1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_MDA_TZSET]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_MDA_TZSET]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_MDA_TZSET$]) -m4trace:configure.ac:114: -1- gl_UCHAR_H -m4trace:configure.ac:114: -1- gl_UCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([1.2], [unicase.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIB_PREPARE +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNISTRING_WOE32DLL_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTRING_WOE32DLL_H]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_UNISTRING_WOE32DLL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNISTRING_WOE32DLL_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UNISTRING_WOE32DLL_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UNISTRING_WOE32DLL_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNISTRING_WOE32DLL_H$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNICASE_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNICASE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNICASE_H$]) -m4trace:configure.ac:114: -1- gl_UNICASE_H -m4trace:configure.ac:114: -1- gl_UNICASE_H_DEFAULTS -m4trace:configure.ac:114: -1- gl_UNICASE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICASE_EMPTY_PREFIX_CONTEXT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICASE_EMPTY_PREFIX_CONTEXT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICASE_EMPTY_PREFIX_CONTEXT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICASE_EMPTY_PREFIX_CONTEXT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICASE_EMPTY_SUFFIX_CONTEXT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICASE_EMPTY_SUFFIX_CONTEXT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICASE_EMPTY_SUFFIX_CONTEXT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICASE_EMPTY_SUFFIX_CONTEXT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.11], [unicase/tolower]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICASE_TOLOWER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICASE_TOLOWER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICASE_TOLOWER_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICASE_TOLOWER_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICASE_TOLOWER_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.11]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([1.2], [unictype.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNICTYPE_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNICTYPE_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNICTYPE_H$]) -m4trace:configure.ac:114: -1- gl_UNICTYPE_H -m4trace:configure.ac:114: -1- gl_UNICTYPE_H_DEFAULTS -m4trace:configure.ac:114: -1- gl_UNICTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_L_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_L_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_L_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_L_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LU_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LU_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LU_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LU_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LM_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LM_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LM_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LM_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_LO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_LO_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_LO_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_LO_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_M_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_M_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_M_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_M_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_MN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_MN_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_MN_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_MN_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_MC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_MC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_MC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_MC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ME_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_ME_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_ME_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_ME_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_N_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_N_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_N_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_N_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_ND_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_ND_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_ND_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_NL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_NL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_NL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_NL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_NO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_NO_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_NO_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_NO_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_P_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_P_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_P_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_P_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PD_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PD_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PD_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PS_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PS_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PS_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PI_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PI_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PI_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PI_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PF_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PF_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PF_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_PO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_PO_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_PO_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_PO_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_S_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_S_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_S_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_S_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SM_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_SM_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_SM_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_SM_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_SC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_SC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_SC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_SK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_SK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_SK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_SO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_SO_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_SO_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_SO_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_Z_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_Z_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_Z_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_Z_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_ZS_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_ZS_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_ZS_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_ZL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_ZL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_ZL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_ZP_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_ZP_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_ZP_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_ZP_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_C_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_C_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_C_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_C_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_CC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_CC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_CC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_CF_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_CF_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_CF_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CS_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_CS_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_CS_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_CS_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CO_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_CO_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_CO_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_CO_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_CATEGORY_CN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_CATEGORY_CN_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_CATEGORY_CN_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_CATEGORY_CN_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_WHITE_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_WHITE_SPACE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_WHITE_SPACE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_WHITE_SPACE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ALPHABETIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ALPHABETIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ALPHABETIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ALPHABETIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ALPHABETIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ALPHABETIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ALPHABETIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ALPHABETIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NOT_A_CHARACTER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_NOT_A_CHARACTER_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_NOT_A_CHARACTER_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_NOT_A_CHARACTER_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_DEFAULT_IGNORABLE_CODE_POINT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DEPRECATED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_DEPRECATED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_DEPRECATED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_DEPRECATED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LOGICAL_ORDER_EXCEPTION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_LOGICAL_ORDER_EXCEPTION_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_LOGICAL_ORDER_EXCEPTION_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_LOGICAL_ORDER_EXCEPTION_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_VARIATION_SELECTOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_VARIATION_SELECTOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_VARIATION_SELECTOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_VARIATION_SELECTOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PRIVATE_USE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PRIVATE_USE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PRIVATE_USE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PRIVATE_USE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UNASSIGNED_CODE_VALUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_UNASSIGNED_CODE_VALUE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_UNASSIGNED_CODE_VALUE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_UNASSIGNED_CODE_VALUE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UPPERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_UPPERCASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_UPPERCASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_UPPERCASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_UPPERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_UPPERCASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_UPPERCASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_UPPERCASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LOWERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_LOWERCASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_LOWERCASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_LOWERCASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_LOWERCASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_LOWERCASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_LOWERCASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_LOWERCASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_TITLECASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_TITLECASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_TITLECASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_TITLECASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CASED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CASED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CASED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CASE_IGNORABLE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CASE_IGNORABLE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CASE_IGNORABLE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CASE_IGNORABLE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_LOWERCASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_LOWERCASED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_LOWERCASED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_LOWERCASED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_UPPERCASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_UPPERCASED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_UPPERCASED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_UPPERCASED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_TITLECASED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_TITLECASED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_TITLECASED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_TITLECASED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEFOLDED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEFOLDED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEFOLDED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEFOLDED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEMAPPED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEMAPPED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEMAPPED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CHANGES_WHEN_CASEMAPPED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SOFT_DOTTED_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_SOFT_DOTTED_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_SOFT_DOTTED_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_SOFT_DOTTED_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ID_START_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ID_START_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ID_START_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_START_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_START_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_START_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ID_CONTINUE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ID_CONTINUE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ID_CONTINUE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_ID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_CONTINUE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_CONTINUE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_ID_CONTINUE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_XID_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_XID_START_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_XID_START_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_XID_START_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_XID_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_XID_CONTINUE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_XID_CONTINUE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_XID_CONTINUE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_START_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_START_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_START_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_START_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_CONTINUE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_CONTINUE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_CONTINUE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ID_COMPAT_MATH_CONTINUE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PATTERN_WHITE_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_WHITE_SPACE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_WHITE_SPACE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_WHITE_SPACE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PATTERN_SYNTAX_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_SYNTAX_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_SYNTAX_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PATTERN_SYNTAX_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_JOIN_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_JOIN_CONTROL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_JOIN_CONTROL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_JOIN_CONTROL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_BASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_BASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_BASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_BASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_EXTEND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_EXTEND_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_EXTEND_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_EXTEND_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_GRAPHEME_EXTEND_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_GRAPHEME_EXTEND_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_GRAPHEME_EXTEND_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_GRAPHEME_EXTEND_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_GRAPHEME_LINK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_LINK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_LINK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_GRAPHEME_LINK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_CONTROL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_CONTROL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_CONTROL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_LEFT_TO_RIGHT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_LEFT_TO_RIGHT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_LEFT_TO_RIGHT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_LEFT_TO_RIGHT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_HEBREW_RIGHT_TO_LEFT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_RIGHT_TO_LEFT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUROPEAN_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUROPEAN_DIGIT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUROPEAN_DIGIT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUROPEAN_DIGIT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_TERMINATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_TERMINATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_TERMINATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EUR_NUM_TERMINATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_DIGIT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_DIGIT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_ARABIC_DIGIT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_COMMON_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_COMMON_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_COMMON_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_COMMON_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_BLOCK_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BLOCK_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BLOCK_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BLOCK_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_SEGMENT_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_SEGMENT_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_SEGMENT_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_SEGMENT_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_WHITESPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_WHITESPACE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_WHITESPACE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_WHITESPACE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_NON_SPACING_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_NON_SPACING_MARK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_NON_SPACING_MARK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_NON_SPACING_MARK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_BOUNDARY_NEUTRAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BOUNDARY_NEUTRAL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BOUNDARY_NEUTRAL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_BOUNDARY_NEUTRAL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_PDF_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_PDF_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_PDF_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_PDF_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_EMBEDDING_OR_OVERRIDE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_BIDI_OTHER_NEUTRAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_OTHER_NEUTRAL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_BIDI_OTHER_NEUTRAL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_BIDI_OTHER_NEUTRAL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_HEX_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_HEX_DIGIT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_HEX_DIGIT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_HEX_DIGIT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ASCII_HEX_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ASCII_HEX_DIGIT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ASCII_HEX_DIGIT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ASCII_HEX_DIGIT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDEOGRAPHIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_IDEOGRAPHIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_IDEOGRAPHIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_IDEOGRAPHIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_UNIFIED_IDEOGRAPH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_UNIFIED_IDEOGRAPH_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_UNIFIED_IDEOGRAPH_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_UNIFIED_IDEOGRAPH_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_RADICAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_RADICAL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_RADICAL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_RADICAL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_UNARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_IDS_UNARY_OPERATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_IDS_UNARY_OPERATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_IDS_UNARY_OPERATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_BINARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_IDS_BINARY_OPERATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_IDS_BINARY_OPERATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_IDS_BINARY_OPERATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IDS_TRINARY_OPERATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_IDS_TRINARY_OPERATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_IDS_TRINARY_OPERATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_IDS_TRINARY_OPERATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_PRESENTATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_PRESENTATION_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_PRESENTATION_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_PRESENTATION_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_BASE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_BASE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_BASE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_MODIFIER_BASE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EMOJI_COMPONENT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_COMPONENT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_COMPONENT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EMOJI_COMPONENT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EXTENDED_PICTOGRAPHIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EXTENDED_PICTOGRAPHIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EXTENDED_PICTOGRAPHIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EXTENDED_PICTOGRAPHIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ZERO_WIDTH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ZERO_WIDTH_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ZERO_WIDTH_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ZERO_WIDTH_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SPACE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_SPACE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_SPACE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_SPACE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NON_BREAK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_NON_BREAK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_NON_BREAK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_NON_BREAK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_ISO_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_ISO_CONTROL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_ISO_CONTROL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_ISO_CONTROL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_FORMAT_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_FORMAT_CONTROL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_FORMAT_CONTROL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_FORMAT_CONTROL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PREPENDED_CONCATENATION_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PREPENDED_CONCATENATION_MARK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PREPENDED_CONCATENATION_MARK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PREPENDED_CONCATENATION_MARK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DASH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_DASH_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_DASH_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_DASH_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_HYPHEN_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_HYPHEN_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_HYPHEN_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_HYPHEN_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PUNCTUATION_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PUNCTUATION_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PUNCTUATION_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LINE_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_LINE_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_LINE_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_LINE_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PARAGRAPH_SEPARATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PARAGRAPH_SEPARATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PARAGRAPH_SEPARATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PARAGRAPH_SEPARATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_QUOTATION_MARK_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_QUOTATION_MARK_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_QUOTATION_MARK_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_QUOTATION_MARK_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_SENTENCE_TERMINAL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_SENTENCE_TERMINAL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_SENTENCE_TERMINAL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_SENTENCE_TERMINAL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_TERMINAL_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_TERMINAL_PUNCTUATION_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_TERMINAL_PUNCTUATION_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_TERMINAL_PUNCTUATION_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_CURRENCY_SYMBOL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_CURRENCY_SYMBOL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_CURRENCY_SYMBOL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_CURRENCY_SYMBOL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_MATH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_MATH_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_MATH_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_MATH_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_OTHER_MATH_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_MATH_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_OTHER_MATH_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_OTHER_MATH_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_PAIRED_PUNCTUATION_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_PAIRED_PUNCTUATION_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_PAIRED_PUNCTUATION_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_PAIRED_PUNCTUATION_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_LEFT_OF_PAIR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_LEFT_OF_PAIR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_LEFT_OF_PAIR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_LEFT_OF_PAIR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_COMBINING_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_COMBINING_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_COMBINING_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_COMBINING_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_COMPOSITE_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_COMPOSITE_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_COMPOSITE_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_COMPOSITE_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DECIMAL_DIGIT_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_DECIMAL_DIGIT_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_DECIMAL_DIGIT_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_DECIMAL_DIGIT_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_NUMERIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_NUMERIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_NUMERIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_NUMERIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_DIACRITIC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_DIACRITIC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_DIACRITIC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_DIACRITIC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_EXTENDER_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_EXTENDER_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_EXTENDER_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_EXTENDER_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_IGNORABLE_CONTROL_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_IGNORABLE_CONTROL_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_IGNORABLE_CONTROL_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_IGNORABLE_CONTROL_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNICTYPE_PROPERTY_REGIONAL_INDICATOR_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNICTYPE_PROPERTY_REGIONAL_INDICATOR_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNICTYPE_PROPERTY_REGIONAL_INDICATOR_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNICTYPE_PROPERTY_REGIONAL_INDICATOR_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-alnum]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALNUM_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-alpha]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_ALPHA_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-blank]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_BLANK_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.8]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-cntrl]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_CNTRL_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.8]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-digit]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_DIGIT_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.8]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-graph]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_GRAPH_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.11], [unictype/ctype-lower]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_LOWER_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.11]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-print]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PRINT_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [unictype/ctype-punct]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_PUNCT_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-space]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_SPACE_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.8]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.11], [unictype/ctype-upper]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER], [gl_LIBUNISTRING_VERSION_CMP([0.9.11])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_UPPER_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.11]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-xdigit]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT], [gl_LIBUNISTRING_VERSION_CMP([0.9.8])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNICTYPE_CTYPE_XDIGIT_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.8]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([1.2], [uninorm.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNINORM_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNINORM_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNINORM_H$]) -m4trace:configure.ac:114: -1- gl_UNINORM_H -m4trace:configure.ac:114: -1- gl_UNINORM_H_DEFAULTS -m4trace:configure.ac:114: -1- gl_UNINORM_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNINORM_NFD_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNINORM_NFD_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNINORM_NFD_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNINORM_NFC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNINORM_NFC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNINORM_NFC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFKD_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNINORM_NFKD_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNINORM_NFKD_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNINORM_NFKD_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNINORM_NFKC_DLL_VARIABLE], ['LIBUNISTRING_DLL_VARIABLE']) +m4trace:configure.ac:114: -1- AC_SUBST([GL_GNULIB_UNINORM_NFKC_DLL_VARIABLE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_GNULIB_UNINORM_NFKC_DLL_VARIABLE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_GNULIB_UNINORM_NFKC_DLL_VARIABLE$]) -m4trace:configure.ac:114: -1- gl_UNISTD_H -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([unistd.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([unistd.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_unistd_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" unistd.h ]AS_TR_SH([unistd.h]) AS_TR_CPP([HAVE_unistd.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([unistd.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_UNISTD_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_UNISTD_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_UNISTD_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_UNISTD_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_UNISTD_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_UNISTD_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_UNISTD_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_UNISTD_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_UNISTD_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_UNISTD_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_UNISTD_H$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[ -#if HAVE_UNISTD_H -# include -#endif -/* Some systems declare various items in the wrong headers. */ -#if !(defined __GLIBC__ && !defined __UCLIBC__) -# include -# include -# include -# if defined _WIN32 && ! defined __CYGWIN__ -# include -# endif -#endif - ]], [access chdir chown copy_file_range dup dup2 dup3 environ euidaccess - execl execle execlp execv execve execvp execvpe - faccessat fchdir - fchownat fdatasync fsync ftruncate getcwd getdomainname getdtablesize - getentropy getgroups gethostname getlogin getlogin_r getpagesize getpass - getusershell setusershell endusershell - group_member isatty lchown link linkat lseek pipe pipe2 pread pwrite - readlink readlinkat rmdir sethostname sleep symlink symlinkat - truncate ttyname_r unlink unlinkat usleep]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_execvpe], [_AC_CHECK_DECLS([execvpe])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_EXECVPE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_EXECVPE$]) -m4trace:configure.ac:114: -1- gl_UNISTD_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([1.2], [unistr.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_EXECVPE], [/* Define to 1 if you have the declaration of \'execvpe\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_EXECVPE]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNISTR_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNISTR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNISTR_H$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([unistr/u8-mbtoucr]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_UNISTR_U8_MBTOUCR]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_UNISTR_U8_MBTOUCR$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-mbtoucr]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR], [gl_LIBUNISTRING_VERSION_CMP([0.9])]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_UNISTR_U8_MBTOUCR], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module unistr/u8-mbtoucr shall be considered present. */ +@%:@undef GNULIB_UNISTR_U8_MBTOUCR]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR], [gl_LIBUNISTRING_VERSION_CMP([0.9])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNISTR_U8_MBTOUCR_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([unistr/u8-uctomb]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_UNISTR_U8_UCTOMB]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_UNISTR_U8_UCTOMB$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-uctomb]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB], [gl_LIBUNISTRING_VERSION_CMP([0.9])]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_UNISTR_U8_UCTOMB], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module unistr/u8-uctomb shall be considered present. */ +@%:@undef GNULIB_UNISTR_U8_UCTOMB]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB], [gl_LIBUNISTRING_VERSION_CMP([0.9])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNISTR_U8_UCTOMB_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([0.9.11], [unitypes.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.11]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNITYPES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNITYPES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNITYPES_H$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_LIBHEADER([0.9.11], [uniwidth.h]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([0.9.11]) +m4trace:configure.ac:114: -1- AH_OUTPUT([unitypes_restrict], [ + /* This definition is a duplicate of the one in unitypes.h. + It is here so that we can cope with an older version of unitypes.h + that does not contain this definition and that is pre-installed among + the public header files. */ + # if defined __restrict \\ + || 2 < __GNUC__ + (95 <= __GNUC_MINOR__) \\ + || __clang_major__ >= 3 + # define _UC_RESTRICT __restrict + # elif 199901L <= __STDC_VERSION__ || defined restrict + # define _UC_RESTRICT restrict + # else + # define _UC_RESTRICT + # endif + ]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_UNIWIDTH_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_UNIWIDTH_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_UNIWIDTH_H$]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_MODULE([1.2], [uniwidth/width]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH], [gl_LIBUNISTRING_VERSION_CMP([1.2])]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([LIBUNISTRING_COMPILE_UNIWIDTH_WIDTH_FALSE]) -m4trace:configure.ac:114: -1- gl_LIBUNISTRING_VERSION_CMP([1.2]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_STDIO_SINGLE_THREAD]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_STDIO_SINGLE_THREAD$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_STDIO_SINGLE_THREAD], [/* Define to 1 if you want the FILE stream functions getc, putc, etc. to use + unlocked I/O if available, throughout the package. Unlocked I/O can improve + performance, sometimes dramatically. But unlocked I/O is safe only in + single-threaded programs, as well as in multithreaded programs for which + you can guarantee that every FILE stream, including stdin, stdout, stderr, + is used only in a single thread. */ +@%:@undef GNULIB_STDIO_SINGLE_THREAD]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([USE_UNLOCKED_IO]) m4trace:configure.ac:114: -1- m4_pattern_allow([^USE_UNLOCKED_IO$]) -m4trace:configure.ac:114: -1- gl_FUNC_GLIBC_UNLOCKED_IO -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_clearerr_unlocked], [_AC_CHECK_DECLS([clearerr_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([USE_UNLOCKED_IO], [/* An alias of GNULIB_STDIO_SINGLE_THREAD. */ +@%:@undef USE_UNLOCKED_IO]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_CLEARERR_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_CLEARERR_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_feof_unlocked], [_AC_CHECK_DECLS([feof_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_CLEARERR_UNLOCKED], [/* Define to 1 if you have the declaration of \'clearerr_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_CLEARERR_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FEOF_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FEOF_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_ferror_unlocked], [_AC_CHECK_DECLS([ferror_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FEOF_UNLOCKED], [/* Define to 1 if you have the declaration of \'feof_unlocked\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_FEOF_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FERROR_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FERROR_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fflush_unlocked], [_AC_CHECK_DECLS([fflush_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FERROR_UNLOCKED], [/* Define to 1 if you have the declaration of \'ferror_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FERROR_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FFLUSH_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FFLUSH_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fgets_unlocked], [_AC_CHECK_DECLS([fgets_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FFLUSH_UNLOCKED], [/* Define to 1 if you have the declaration of \'fflush_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FFLUSH_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FGETS_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FGETS_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fputc_unlocked], [_AC_CHECK_DECLS([fputc_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FGETS_UNLOCKED], [/* Define to 1 if you have the declaration of \'fgets_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FGETS_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FPUTC_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FPUTC_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fputs_unlocked], [_AC_CHECK_DECLS([fputs_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FPUTC_UNLOCKED], [/* Define to 1 if you have the declaration of \'fputc_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FPUTC_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FPUTS_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FPUTS_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fread_unlocked], [_AC_CHECK_DECLS([fread_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FPUTS_UNLOCKED], [/* Define to 1 if you have the declaration of \'fputs_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FPUTS_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FREAD_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FREAD_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_fwrite_unlocked], [_AC_CHECK_DECLS([fwrite_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FREAD_UNLOCKED], [/* Define to 1 if you have the declaration of \'fread_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FREAD_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_FWRITE_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_FWRITE_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_getc_unlocked], [_AC_CHECK_DECLS([getc_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_FWRITE_UNLOCKED], [/* Define to 1 if you have the declaration of \'fwrite_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_FWRITE_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_GETC_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETC_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_getchar_unlocked], [_AC_CHECK_DECLS([getchar_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_GETC_UNLOCKED], [/* Define to 1 if you have the declaration of \'getc_unlocked\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_GETC_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_GETCHAR_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_GETCHAR_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_putc_unlocked], [_AC_CHECK_DECLS([putc_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_GETCHAR_UNLOCKED], [/* Define to 1 if you have the declaration of \'getchar_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_GETCHAR_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PUTC_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PUTC_UNLOCKED$]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Check_Decl_putchar_unlocked], [_AC_CHECK_DECLS([putchar_unlocked])]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PUTC_UNLOCKED], [/* Define to 1 if you have the declaration of \'putc_unlocked\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_PUTC_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_PUTCHAR_UNLOCKED]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_PUTCHAR_UNLOCKED$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_PUTCHAR_UNLOCKED], [/* Define to 1 if you have the declaration of \'putchar_unlocked\', and to 0 if + you don\'t. */ +@%:@undef HAVE_DECL_PUTCHAR_UNLOCKED]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_C_VARARRAYS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_C_VARARRAYS$]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_C_VARARRAYS], [/* Define to 1 if C supports variable-length arrays. */ +@%:@undef HAVE_C_VARARRAYS]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([__STDC_NO_VLA__]) m4trace:configure.ac:114: -1- m4_pattern_allow([^__STDC_NO_VLA__$]) -m4trace:configure.ac:114: -1- gl_WCHAR_H -m4trace:configure.ac:114: -1- gl_WCHAR_H_INLINE_OK -m4trace:configure.ac:114: -1- gl_CHECK_NEXT_HEADERS([wchar.h]) -m4trace:configure.ac:114: -1- gl_NEXT_HEADERS_INTERNAL([wchar.h], [check]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_wchar_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" wchar.h ]AS_TR_SH([wchar.h]) AS_TR_CPP([HAVE_wchar.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- gl_ABSOLUTE_HEADER_ONE([wchar.h]) +m4trace:configure.ac:114: -1- AH_OUTPUT([__STDC_NO_VLA__], [/* Define to 1 if C does not support variable-length arrays, and if the + compiler does not already define this. */ +@%:@undef __STDC_NO_VLA__]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCHAR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_WCHAR_H], [AS_VAR_GET([gl_next_header])]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_WCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_WCHAR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([NEXT_AS_FIRST_DIRECTIVE_WCHAR_H], [$gl_next_as_first_directive]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([NEXT_AS_FIRST_DIRECTIVE_WCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^NEXT_AS_FIRST_DIRECTIVE_WCHAR_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WCHAR_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WCHAR_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WCHAR_H$]) -m4trace:configure.ac:114: -1- gl_FEATURES_H -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_features_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" features.h ]AS_TR_SH([features.h]) AS_TR_CPP([HAVE_features.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_FEATURES_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_FEATURES_H]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_FEATURES_H]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_FEATURES_H]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_FEATURES_H$]) +m4trace:configure.ac:114: -1- AC_SUBST([HAVE_WINT_T]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([HAVE_WINT_T]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_WINT_T$]) -m4trace:configure.ac:114: -1- gl_WARN_ON_USE_PREPARE([[ - #include - ]], [btowc wctob mbsinit mbrtowc mbrlen mbsrtowcs mbsnrtowcs wcrtomb - wcsrtombs wcsnrtombs wcwidth - wmemchr wmemcmp wmemcpy wmemmove wmempcpy wmemset - wcslen wcsnlen wcscpy wcpcpy wcsncpy wcpncpy wcscat wcsncat wcscmp - wcsncmp wcscasecmp wcsncasecmp wcscoll wcsxfrm wcsdup wcschr wcsrchr - wcscspn wcsspn wcspbrk wcsstr wcstok wcswidth wcsftime - ]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_WCSDUP]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_WCSDUP$]) -m4trace:configure.ac:114: -1- gl_WCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_WCTYPE_H -m4trace:configure.ac:114: -1- gl_WCTYPE_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_FUNC_WCWIDTH -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Header_wchar_h], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_header_]]_AC_LANG_ABBREV[[_list], - [" wchar.h ]AS_TR_SH([wchar.h]) AS_TR_CPP([HAVE_wchar.h])["])])_AC_HEADERS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_Func_wcwidth], [m4_divert_text([INIT_PREPARE], - [AS_VAR_APPEND([ac_func_]]_AC_LANG_ABBREV[[_list], - [" wcwidth ]AS_TR_CPP([HAVE_wcwidth])["])])_AC_FUNCS_EXPANSION(_AC_LANG_ABBREV)]) -m4trace:configure.ac:114: -1- AC_DEFUN([_AC_UNDECLARED_BUILTIN_c], [_AC_UNDECLARED_BUILTIN]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_WCSDUP], [/* Define to 1 if you have the declaration of \'wcsdup\', and to 0 if you don\'t. + */ +@%:@undef HAVE_DECL_WCSDUP]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCHAR_H], [/* Define to 1 if you have the header file. */ +@%:@undef HAVE_WCHAR_H]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_WCWIDTH], [/* Define to 1 if you have the \'wcwidth\' function. */ +@%:@undef HAVE_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([HAVE_DECL_WCWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^HAVE_DECL_WCWIDTH$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_WCWIDTH], [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]) +m4trace:configure.ac:114: -1- AH_OUTPUT([HAVE_DECL_WCWIDTH], [/* Define to 1 if you have the declaration of \'wcwidth\', and to 0 if you + don\'t. */ +@%:@undef HAVE_DECL_WCWIDTH]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_WCWIDTH], [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WCWIDTH_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WCWIDTH_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WCWIDTH_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WCWIDTH_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WCWIDTH_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WCWIDTH_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WCWIDTH_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WCWIDTH_FALSE]) -m4trace:configure.ac:114: -1- AM_COND_IF([GL_COND_OBJ_WCWIDTH], [ - gl_PREREQ_WCWIDTH - ]) -m4trace:configure.ac:114: -1- gl_PREREQ_WCWIDTH -m4trace:configure.ac:114: -1- gl_WCHAR_MODULE_INDICATOR([wcwidth]) -m4trace:configure.ac:114: -1- gl_WCHAR_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_STDLIB_H_REQUIRE_DEFAULTS -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE([wcwidth]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_SET_VARIABLE_AUX([GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[wcwidth]], - [abcdefghijklmnopqrstuvwxyz./-], - [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])], [gl_MODULE_INDICATOR_CONDITION]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR_FOR_TESTS([wcwidth]) +m4trace:configure.ac:114: -1- _AM_COND_IF([GL_COND_OBJ_WCWIDTH]) +m4trace:configure.ac:114: -1- _AM_COND_ENDIF([GL_COND_OBJ_WCWIDTH]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_TEST_WCWIDTH]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_TEST_WCWIDTH$]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_MUTEX], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_TEST_WCWIDTH], [/* Define to 1 when the gnulib module wcwidth should be tested. */ +@%:@undef GNULIB_TEST_WCWIDTH]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_WINDOWS_MUTEX], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_MUTEX_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_MUTEX_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_MUTEX_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_MUTEX_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_MUTEX_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_MUTEX_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_MUTEX_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_MUTEX_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_ONCE], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_WINDOWS_ONCE], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_ONCE_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_ONCE_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_ONCE_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_ONCE_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_ONCE_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_ONCE_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_ONCE_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_ONCE_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RECMUTEX], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_WINDOWS_RECMUTEX], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_RECMUTEX_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_RECMUTEX_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_RECMUTEX_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_RECMUTEX_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_RECMUTEX_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_RECMUTEX_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_RECMUTEX_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_RECMUTEX_FALSE]) -m4trace:configure.ac:114: -1- gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RWLOCK], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) m4trace:configure.ac:114: -1- AM_CONDITIONAL([GL_COND_OBJ_WINDOWS_RWLOCK], [case "$host_os" in mingw* | windows*) true;; *) false;; esac]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_RWLOCK_TRUE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_RWLOCK_TRUE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_RWLOCK_TRUE$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_COND_OBJ_WINDOWS_RWLOCK_FALSE]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_COND_OBJ_WINDOWS_RWLOCK_FALSE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_COND_OBJ_WINDOWS_RWLOCK_FALSE$]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_RWLOCK_TRUE]) m4trace:configure.ac:114: -1- _AM_SUBST_NOTMAKE([GL_COND_OBJ_WINDOWS_RWLOCK_FALSE]) -m4trace:configure.ac:114: -1- gl_XALLOC -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([xalloc]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_XALLOC]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_XALLOC$]) -m4trace:configure.ac:114: -1- gl_MODULE_INDICATOR([xalloc-die]) +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_XALLOC], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module xalloc shall be considered present. */ +@%:@undef GNULIB_XALLOC]) +m4trace:configure.ac:114: -1- AC_DEFINE_TRACE_LITERAL([GNULIB_XALLOC_DIE]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GNULIB_XALLOC_DIE$]) -m4trace:configure.ac:114: -1- gl_COMMON +m4trace:configure.ac:114: -1- AH_OUTPUT([GNULIB_XALLOC_DIE], [/* Define to a C preprocessor expression that evaluates to 1 or 0, depending + whether the gnulib module xalloc-die shall be considered present. */ +@%:@undef GNULIB_XALLOC_DIE]) +m4trace:configure.ac:114: -1- AC_SUBST([gltests_WITNESS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([gltests_WITNESS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^gltests_WITNESS$]) -m4trace:configure.ac:114: -1- gl_CC_GNULIB_WARNINGS -m4trace:configure.ac:114: -1- gl_CC_ALLOW_WARNINGS +m4trace:configure.ac:114: -1- AC_SUBST([GL_CFLAG_ALLOW_WARNINGS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_CFLAG_ALLOW_WARNINGS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_CFLAG_ALLOW_WARNINGS$]) +m4trace:configure.ac:114: -1- AC_SUBST([GL_CFLAG_GNULIB_WARNINGS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([GL_CFLAG_GNULIB_WARNINGS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^GL_CFLAG_GNULIB_WARNINGS$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBGRT_LIBDEPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBGRT_LIBDEPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBGRT_LIBDEPS$]) +m4trace:configure.ac:114: -1- AC_SUBST([LIBGRT_LTLIBDEPS]) +m4trace:configure.ac:114: -1- AC_SUBST_TRACE([LIBGRT_LTLIBDEPS]) m4trace:configure.ac:114: -1- m4_pattern_allow([^LIBGRT_LTLIBDEPS$]) +m4trace:configure.ac:115: -1- AC_DEFINE_TRACE_LITERAL([size_t]) m4trace:configure.ac:115: -1- m4_pattern_allow([^size_t$]) +m4trace:configure.ac:115: -1- AH_OUTPUT([size_t], [/* Define as \'unsigned int\' if doesn\'t define. */ +@%:@undef size_t]) +m4trace:configure.ac:116: -1- AH_OUTPUT([HAVE_SETLOCALE], [/* Define to 1 if you have the \'setlocale\' function. */ +@%:@undef HAVE_SETLOCALE]) +m4trace:configure.ac:116: -1- AC_DEFINE_TRACE_LITERAL([HAVE_SETLOCALE]) m4trace:configure.ac:116: -1- m4_pattern_allow([^HAVE_SETLOCALE$]) m4trace:configure.ac:133: -1- AM_CONDITIONAL([WOE32DLL], [test $is_woe32dll = yes]) +m4trace:configure.ac:133: -1- AC_SUBST([WOE32DLL_TRUE]) +m4trace:configure.ac:133: -1- AC_SUBST_TRACE([WOE32DLL_TRUE]) m4trace:configure.ac:133: -1- m4_pattern_allow([^WOE32DLL_TRUE$]) +m4trace:configure.ac:133: -1- AC_SUBST([WOE32DLL_FALSE]) +m4trace:configure.ac:133: -1- AC_SUBST_TRACE([WOE32DLL_FALSE]) m4trace:configure.ac:133: -1- m4_pattern_allow([^WOE32DLL_FALSE$]) m4trace:configure.ac:133: -1- _AM_SUBST_NOTMAKE([WOE32DLL_TRUE]) m4trace:configure.ac:133: -1- _AM_SUBST_NOTMAKE([WOE32DLL_FALSE]) +m4trace:configure.ac:135: -1- AC_DEFINE_TRACE_LITERAL([WOE32DLL]) m4trace:configure.ac:135: -1- m4_pattern_allow([^WOE32DLL$]) +m4trace:configure.ac:135: -1- AH_OUTPUT([WOE32DLL], [/* Define when --enable-shared is used on mingw or Cygwin. */ +@%:@undef WOE32DLL]) +m4trace:configure.ac:140: -1- AH_OUTPUT([zzzz1], [ +/* On Windows, variables that may be in a DLL must be marked specially. + But here, the only such variable is \'exit_failure\', and it is always + built into a static library, never into a shared library. */ +#if defined WOE32DLL && !defined IN_RELOCWRAPPER && 0 +# define DLL_VARIABLE __declspec (dllimport) +#else +# define DLL_VARIABLE +#endif + +/* Extra OS/2 (emx+gcc) defines. */ +#if defined __EMX__ && !defined __KLIBC__ +# include "intl/os2compat.h" +#endif +]) +m4trace:configure.ac:158: -1- AC_SUBST([PERL]) +m4trace:configure.ac:158: -1- AC_SUBST_TRACE([PERL]) m4trace:configure.ac:158: -1- m4_pattern_allow([^PERL$]) +m4trace:configure.ac:162: -1- AC_SUBST([CROSS_COMPILING]) +m4trace:configure.ac:162: -1- AC_SUBST_TRACE([CROSS_COMPILING]) m4trace:configure.ac:162: -1- m4_pattern_allow([^CROSS_COMPILING$]) -m4trace:configure.ac:165: -1- gl_PROG_ANSI_CXX([CXX], [ANSICXX]) +m4trace:configure.ac:165: -1- AC_SUBST([CXX]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([CXX]) m4trace:configure.ac:165: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:165: -1- AC_SUBST([ac_ct_CXX]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([ac_ct_CXX]) m4trace:configure.ac:165: -1- m4_pattern_allow([^ac_ct_CXX$]) +m4trace:configure.ac:165: -1- AC_SUBST([CXX]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([CXX]) m4trace:configure.ac:165: -1- m4_pattern_allow([^CXX$]) +m4trace:configure.ac:165: -1- AC_SUBST([CXXFLAGS]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([CXXFLAGS]) m4trace:configure.ac:165: -1- m4_pattern_allow([^CXXFLAGS$]) +m4trace:configure.ac:165: -1- AC_SUBST([CXX]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([CXX]) m4trace:configure.ac:165: -1- m4_pattern_allow([^CXX$]) m4trace:configure.ac:165: -1- AM_CONDITIONAL([ANSICXX], [test "$CXX" != no]) +m4trace:configure.ac:165: -1- AC_SUBST([ANSICXX_TRUE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([ANSICXX_TRUE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^ANSICXX_TRUE$]) +m4trace:configure.ac:165: -1- AC_SUBST([ANSICXX_FALSE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([ANSICXX_FALSE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^ANSICXX_FALSE$]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([ANSICXX_TRUE]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([ANSICXX_FALSE]) -m4trace:configure.ac:165: -1- _AM_DEPENDENCIES([CXX]) +m4trace:configure.ac:165: -1- AC_SUBST([CXXDEPMODE], [depmode=$am_cv_CXX_dependencies_compiler_type]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([CXXDEPMODE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^CXXDEPMODE$]) m4trace:configure.ac:165: -1- AM_CONDITIONAL([am__fastdepCXX], [ test "x$enable_dependency_tracking" != xno \ && test "$am_cv_CXX_dependencies_compiler_type" = gcc3]) +m4trace:configure.ac:165: -1- AC_SUBST([am__fastdepCXX_TRUE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([am__fastdepCXX_TRUE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^am__fastdepCXX_TRUE$]) +m4trace:configure.ac:165: -1- AC_SUBST([am__fastdepCXX_FALSE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([am__fastdepCXX_FALSE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^am__fastdepCXX_FALSE$]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_TRUE]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_FALSE]) m4trace:configure.ac:165: -1- AM_CONDITIONAL([am__fastdepCXX], [false]) +m4trace:configure.ac:165: -1- AC_SUBST([am__fastdepCXX_TRUE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([am__fastdepCXX_TRUE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^am__fastdepCXX_TRUE$]) +m4trace:configure.ac:165: -1- AC_SUBST([am__fastdepCXX_FALSE]) +m4trace:configure.ac:165: -1- AC_SUBST_TRACE([am__fastdepCXX_FALSE]) m4trace:configure.ac:165: -1- m4_pattern_allow([^am__fastdepCXX_FALSE$]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_TRUE]) m4trace:configure.ac:165: -1- _AM_SUBST_NOTMAKE([am__fastdepCXX_FALSE]) +m4trace:configure.ac:176: -1- AC_SUBST([LIBSCHED]) +m4trace:configure.ac:176: -1- AC_SUBST_TRACE([LIBSCHED]) m4trace:configure.ac:176: -1- m4_pattern_allow([^LIBSCHED$]) m4trace:configure.ac:190: -1- AM_CONDITIONAL([ENABLE_LIBASPRINTF], [test -n "$SUBDIR_libasprintf"]) +m4trace:configure.ac:190: -1- AC_SUBST([ENABLE_LIBASPRINTF_TRUE]) +m4trace:configure.ac:190: -1- AC_SUBST_TRACE([ENABLE_LIBASPRINTF_TRUE]) m4trace:configure.ac:190: -1- m4_pattern_allow([^ENABLE_LIBASPRINTF_TRUE$]) +m4trace:configure.ac:190: -1- AC_SUBST([ENABLE_LIBASPRINTF_FALSE]) +m4trace:configure.ac:190: -1- AC_SUBST_TRACE([ENABLE_LIBASPRINTF_FALSE]) m4trace:configure.ac:190: -1- m4_pattern_allow([^ENABLE_LIBASPRINTF_FALSE$]) m4trace:configure.ac:190: -1- _AM_SUBST_NOTMAKE([ENABLE_LIBASPRINTF_TRUE]) m4trace:configure.ac:190: -1- _AM_SUBST_NOTMAKE([ENABLE_LIBASPRINTF_FALSE]) +m4trace:configure.ac:194: -1- AC_SUBST([ENABLE_SHARED]) +m4trace:configure.ac:194: -1- AC_SUBST_TRACE([ENABLE_SHARED]) m4trace:configure.ac:194: -1- m4_pattern_allow([^ENABLE_SHARED$]) +m4trace:configure.ac:196: -1- AC_CONFIG_SUBDIRS([intl]) +m4trace:configure.ac:196: -1- AC_SUBST([subdirs], ["$subdirs intl"]) +m4trace:configure.ac:196: -1- AC_SUBST_TRACE([subdirs]) m4trace:configure.ac:196: -1- m4_pattern_allow([^subdirs$]) +m4trace:configure.ac:198: -1- AC_CONFIG_SUBDIRS([libasprintf]) +m4trace:configure.ac:198: -1- AC_SUBST([subdirs], ["$subdirs libasprintf"]) +m4trace:configure.ac:198: -1- AC_SUBST_TRACE([subdirs]) m4trace:configure.ac:198: -1- m4_pattern_allow([^subdirs$]) +m4trace:configure.ac:200: -1- AC_CONFIG_FILES([Makefile]) +m4trace:configure.ac:201: -1- AC_CONFIG_FILES([uninstalled-config.sh]) +m4trace:configure.ac:203: -1- AC_CONFIG_FILES([doc/Makefile]) +m4trace:configure.ac:205: -1- AC_CONFIG_FILES([intl-java/Makefile]) +m4trace:configure.ac:207: -1- AC_CONFIG_FILES([intl-csharp/Makefile]) +m4trace:configure.ac:209: -1- AC_CONFIG_FILES([gnulib-lib/Makefile]) +m4trace:configure.ac:211: -1- AC_CONFIG_FILES([src/Makefile]) +m4trace:configure.ac:212: -1- AC_CONFIG_FILES([src/gettext.sh], [chmod a+x src/gettext.sh]) +m4trace:configure.ac:214: -1- AC_CONFIG_FILES([po/Makefile.in]) +m4trace:configure.ac:216: -1- AC_CONFIG_FILES([man/Makefile], [FIX_MAKEFILE_DISTRIB]) +m4trace:configure.ac:218: -1- AC_CONFIG_FILES([man/x-to-1]) +m4trace:configure.ac:220: -1- AC_CONFIG_FILES([m4/Makefile]) +m4trace:configure.ac:222: -1- AC_CONFIG_FILES([tests/Makefile]) +m4trace:configure.ac:224: -1- AC_SUBST([LIB@&t@OBJS], [$ac_libobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([LIB@&t@OBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^LIB@&t@OBJS$]) +m4trace:configure.ac:224: -1- AC_SUBST([LTLIBOBJS], [$ac_ltlibobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([LTLIBOBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^LTLIBOBJS$]) m4trace:configure.ac:224: -1- AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"]) +m4trace:configure.ac:224: -1- AC_SUBST([am__EXEEXT_TRUE]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([am__EXEEXT_TRUE]) m4trace:configure.ac:224: -1- m4_pattern_allow([^am__EXEEXT_TRUE$]) +m4trace:configure.ac:224: -1- AC_SUBST([am__EXEEXT_FALSE]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([am__EXEEXT_FALSE]) m4trace:configure.ac:224: -1- m4_pattern_allow([^am__EXEEXT_FALSE$]) m4trace:configure.ac:224: -1- _AM_SUBST_NOTMAKE([am__EXEEXT_TRUE]) m4trace:configure.ac:224: -1- _AM_SUBST_NOTMAKE([am__EXEEXT_FALSE]) +m4trace:configure.ac:224: -1- AC_SUBST([gl_LIBOBJS], [$gl_libobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gl_LIBOBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gl_LIBOBJS$]) +m4trace:configure.ac:224: -1- AC_SUBST([gl_LTLIBOBJS], [$gl_ltlibobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gl_LTLIBOBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gl_LTLIBOBJS$]) +m4trace:configure.ac:224: -1- AC_SUBST([gl_LIBOBJDEPS], [$gl_libobjdeps]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gl_LIBOBJDEPS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gl_LIBOBJDEPS$]) +m4trace:configure.ac:224: -1- AC_SUBST([gltests_LIBOBJS], [$gltests_libobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gltests_LIBOBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gltests_LIBOBJS$]) +m4trace:configure.ac:224: -1- AC_SUBST([gltests_LTLIBOBJS], [$gltests_ltlibobjs]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gltests_LTLIBOBJS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gltests_LTLIBOBJS$]) +m4trace:configure.ac:224: -1- AC_SUBST([gltests_LIBOBJDEPS], [$gltests_libobjdeps]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([gltests_LIBOBJDEPS]) m4trace:configure.ac:224: -1- m4_pattern_allow([^gltests_LIBOBJDEPS$]) -m4trace:configure.ac:224: -1- _AC_AM_CONFIG_HEADER_HOOK(["$ac_file"]) -m4trace:configure.ac:224: -1- _AM_OUTPUT_DEPENDENCY_COMMANDS -m4trace:configure.ac:224: -1- AM_RUN_LOG([cd "$am_dirpart" \ - && sed -e '/# am--include-marker/d' "$am_filepart" \ - | $MAKE -f - am--depfiles]) -m4trace:configure.ac:224: -1- _LT_PROG_LTMAIN -m4trace:configure.ac:224: -1- FIX_MAKEFILE_DISTRIB +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([top_builddir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([top_build_prefix]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([srcdir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([abs_srcdir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([top_srcdir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([abs_top_srcdir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([builddir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([abs_builddir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([abs_top_builddir]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([INSTALL]) +m4trace:configure.ac:224: -1- AC_SUBST_TRACE([MKDIR_P]) +m4trace:configure.ac:224: -1- AC_REQUIRE_AUX_FILE([ltmain.sh]) diff --git a/relibc b/relibc new file mode 100644 index 0000000000..e69de29bb2