1 # 1 "cvtpath.c" 2 # 1 "<built-in>" 3 # 1 "<command-line>" 4 # 1 "cvtpath.c" 5 /* 6 * CDDL HEADER START 7 * 8 * The contents of this file are subject to the terms of the 9 * Common Development and Distribution License (the "License"). 10 * You may not use this file except in compliance with the License. 11 * 12 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 13 * or http://www.opensolaris.org/os/licensing. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * 17 * When distributing Covered Code, include this CDDL HEADER in each 18 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 19 * If applicable, add the following below this CDDL HEADER, with the 20 * fields enclosed by brackets "[]" replaced with your own identifying 21 * information: Portions Copyright [yyyy] [name of copyright owner] 22 * 23 * CDDL HEADER END 24 */ 25 26 /* 27 * Copyright 1993 Sun Microsystems, Inc. All rights reserved. 28 * Use is subject to license terms. 29 */ 30 31 32 33 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/string.h" 1 34 /* 35 * CDDL HEADER START 36 * 37 * The contents of this file are subject to the terms of the 38 * Common Development and Distribution License (the "License"). 39 * You may not use this file except in compliance with the License. 40 * 41 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 42 * or http://www.opensolaris.org/os/licensing. 43 * See the License for the specific language governing permissions 44 * and limitations under the License. 45 * 46 * When distributing Covered Code, include this CDDL HEADER in each 47 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 48 * If applicable, add the following below this CDDL HEADER, with the 49 * fields enclosed by brackets "[]" replaced with your own identifying 50 * information: Portions Copyright [yyyy] [name of copyright owner] 51 * 52 * CDDL HEADER END 53 */ 54 55 /* 56 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 57 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. 58 */ 59 60 /* Copyright (c) 1988 AT&T */ 61 /* All Rights Reserved */ 62 63 64 65 66 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/iso/string_iso.h" 1 67 /* 68 * CDDL HEADER START 69 * 70 * The contents of this file are subject to the terms of the 71 * Common Development and Distribution License, Version 1.0 only 72 * (the "License"). You may not use this file except in compliance 73 * with the License. 74 * 75 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 76 * or http://www.opensolaris.org/os/licensing. 77 * See the License for the specific language governing permissions 78 * and limitations under the License. 79 * 80 * When distributing Covered Code, include this CDDL HEADER in each 81 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 82 * If applicable, add the following below this CDDL HEADER, with the 83 * fields enclosed by brackets "[]" replaced with your own identifying 84 * information: Portions Copyright [yyyy] [name of copyright owner] 85 * 86 * CDDL HEADER END 87 */ 88 /* Copyright (c) 1988 AT&T */ 89 /* All Rights Reserved */ 90 91 92 /* 93 * Copyright 2014 Garrett D'Amore <garrett@damore.org> 94 * Copyright 2014 PALO, Richard. 95 * 96 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 97 * Use is subject to license terms. 98 */ 99 100 /* 101 * An application should not include this header directly. Instead it 102 * should be included only through the inclusion of other Sun headers. 103 * 104 * The contents of this header is limited to identifiers specified in the 105 * C Standard. Any new identifiers specified in future amendments to the 106 * C Standard must be placed in this header. If these new identifiers 107 * are required to also be in the C++ Standard "std" namespace, then for 108 * anything other than macro definitions, corresponding "using" directives 109 * must also be added to <string.h>. 110 */ 111 112 113 114 115 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 1 116 /* 117 * CDDL HEADER START 118 * 119 * The contents of this file are subject to the terms of the 120 * Common Development and Distribution License (the "License"). 121 * You may not use this file except in compliance with the License. 122 * 123 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 124 * or http://www.opensolaris.org/os/licensing. 125 * See the License for the specific language governing permissions 126 * and limitations under the License. 127 * 128 * When distributing Covered Code, include this CDDL HEADER in each 129 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 130 * If applicable, add the following below this CDDL HEADER, with the 131 * fields enclosed by brackets "[]" replaced with your own identifying 132 * information: Portions Copyright [yyyy] [name of copyright owner] 133 * 134 * CDDL HEADER END 135 */ 136 137 /* 138 * Copyright 2013 Garrett D'Amore <garrett@damore.org> 139 * Copyright 2016 Joyent, Inc. 140 * 141 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 142 * Use is subject to license terms. 143 */ 144 145 146 147 148 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/ccompile.h" 1 149 /* 150 * CDDL HEADER START 151 * 152 * The contents of this file are subject to the terms of the 153 * Common Development and Distribution License, Version 1.0 only 154 * (the "License"). You may not use this file except in compliance 155 * with the License. 156 * 157 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 158 * or http://www.opensolaris.org/os/licensing. 159 * See the License for the specific language governing permissions 160 * and limitations under the License. 161 * 162 * When distributing Covered Code, include this CDDL HEADER in each 163 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 164 * If applicable, add the following below this CDDL HEADER, with the 165 * fields enclosed by brackets "[]" replaced with your own identifying 166 * information: Portions Copyright [yyyy] [name of copyright owner] 167 * 168 * CDDL HEADER END 169 */ 170 /* 171 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 172 * Use is subject to license terms. 173 */ 174 /* 175 * Copyright 2015 EveryCity Ltd. All rights reserved. 176 */ 177 178 179 180 181 /* 182 * This file contains definitions designed to enable different compilers 183 * to be used harmoniously on Solaris systems. 184 */ 185 186 187 188 189 190 /* 191 * Allow for version tests for compiler bugs and features. 192 */ 193 # 54 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/ccompile.h" 194 /* 195 * analogous to lint's PRINTFLIKEn 196 */ 197 198 199 200 201 202 /* 203 * Handle the kernel printf routines that can take '%b' too 204 */ 205 # 78 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/ccompile.h" 206 /* 207 * This one's pretty obvious -- the function never returns 208 */ 209 210 211 /* 212 * The function is 'extern inline' and expects GNU C89 behaviour, not C99 213 * behaviour. 214 * 215 * Should only be used on 'extern inline' definitions for GCC. 216 */ 217 218 219 220 221 222 223 /* 224 * The function has control flow such that it may return multiple times (in 225 * the manner of setjmp or vfork) 226 */ 227 228 229 230 231 232 233 /* 234 * This is an appropriate label for functions that do not 235 * modify their arguments, e.g. strlen() 236 */ 237 238 239 /* 240 * This is a stronger form of __pure__. Can be used for functions 241 * that do not modify their arguments and don't depend on global 242 * memory. 243 */ 244 245 246 247 248 /* 249 * This attribute, attached to a variable, means that the variable is meant to 250 * be possibly unused. GCC will not produce a warning for this variable. 251 */ 252 # 138 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/ccompile.h" 253 /* 254 * Shorthand versions for readability 255 */ 256 # 34 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 2 257 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/isa_defs.h" 1 258 /* 259 * CDDL HEADER START 260 * 261 * The contents of this file are subject to the terms of the 262 * Common Development and Distribution License (the "License"). 263 * You may not use this file except in compliance with the License. 264 * 265 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 266 * or http://www.opensolaris.org/os/licensing. 267 * See the License for the specific language governing permissions 268 * and limitations under the License. 269 * 270 * 271 * When distributing Covered Code, include this CDDL HEADER in each 272 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 273 * If applicable, add the following below this CDDL HEADER, with the 274 * fields enclosed by brackets "[]" replaced with your own identifying 275 * information: Portions Copyright [yyyy] [name of copyright owner] 276 * 277 * CDDL HEADER END 278 */ 279 280 /* 281 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 282 * Use is subject to license terms. 283 * Copyright 2016 Joyent, Inc. 284 */ 285 286 287 288 289 /* 290 * This header file serves to group a set of well known defines and to 291 * set these for each instruction set architecture. These defines may 292 * be divided into two groups; characteristics of the processor and 293 * implementation choices for Solaris on a processor. 294 * 295 * Processor Characteristics: 296 * 297 * _LITTLE_ENDIAN / _BIG_ENDIAN: 298 * The natural byte order of the processor. A pointer to an int points 299 * to the least/most significant byte of that int. 300 * 301 * _STACK_GROWS_UPWARD / _STACK_GROWS_DOWNWARD: 302 * The processor specific direction of stack growth. A push onto the 303 * stack increases/decreases the stack pointer, so it stores data at 304 * successively higher/lower addresses. (Stackless machines ignored 305 * without regrets). 306 * 307 * _LONG_LONG_HTOL / _LONG_LONG_LTOH: 308 * A pointer to a long long points to the most/least significant long 309 * within that long long. 310 * 311 * _BIT_FIELDS_HTOL / _BIT_FIELDS_LTOH: 312 * The C compiler assigns bit fields from the high/low to the low/high end 313 * of an int (most to least significant vs. least to most significant). 314 * 315 * _IEEE_754: 316 * The processor (or supported implementations of the processor) 317 * supports the ieee-754 floating point standard. No other floating 318 * point standards are supported (or significant). Any other supported 319 * floating point formats are expected to be cased on the ISA processor 320 * symbol. 321 * 322 * _CHAR_IS_UNSIGNED / _CHAR_IS_SIGNED: 323 * The C Compiler implements objects of type `char' as `unsigned' or 324 * `signed' respectively. This is really an implementation choice of 325 * the compiler writer, but it is specified in the ABI and tends to 326 * be uniform across compilers for an instruction set architecture. 327 * Hence, it has the properties of a processor characteristic. 328 * 329 * _CHAR_ALIGNMENT / _SHORT_ALIGNMENT / _INT_ALIGNMENT / _LONG_ALIGNMENT / 330 * _LONG_LONG_ALIGNMENT / _DOUBLE_ALIGNMENT / _LONG_DOUBLE_ALIGNMENT / 331 * _POINTER_ALIGNMENT / _FLOAT_ALIGNMENT: 332 * The ABI defines alignment requirements of each of the primitive 333 * object types. Some, if not all, may be hardware requirements as 334 * well. The values are expressed in "byte-alignment" units. 335 * 336 * _MAX_ALIGNMENT: 337 * The most stringent alignment requirement as specified by the ABI. 338 * Equal to the maximum of all the above _XXX_ALIGNMENT values. 339 * 340 * _MAX_ALIGNMENT_TYPE: 341 * The name of the C type that has the value descried in _MAX_ALIGNMENT. 342 * 343 * _ALIGNMENT_REQUIRED: 344 * True or false (1 or 0) whether or not the hardware requires the ABI 345 * alignment. 346 * 347 * _LONG_LONG_ALIGNMENT_32 348 * The 32-bit ABI supported by a 64-bit kernel may have different 349 * alignment requirements for primitive object types. The value of this 350 * identifier is expressed in "byte-alignment" units. 351 * 352 * _HAVE_CPUID_INSN 353 * This indicates that the architecture supports the 'cpuid' 354 * instruction as defined by Intel. (Intel allows other vendors 355 * to extend the instruction for their own purposes.) 356 * 357 * 358 * Implementation Choices: 359 * 360 * _ILP32 / _LP64: 361 * This specifies the compiler data type implementation as specified in 362 * the relevant ABI. The choice between these is strongly influenced 363 * by the underlying hardware, but is not absolutely tied to it. 364 * Currently only two data type models are supported: 365 * 366 * _ILP32: 367 * Int/Long/Pointer are 32 bits. This is the historical UNIX 368 * and Solaris implementation. Due to its historical standing, 369 * this is the default case. 370 * 371 * _LP64: 372 * Long/Pointer are 64 bits, Int is 32 bits. This is the chosen 373 * implementation for 64-bit ABIs such as SPARC V9. 374 * 375 * _I32LPx: 376 * A compilation environment where 'int' is 32-bit, and 377 * longs and pointers are simply the same size. 378 * 379 * In all cases, Char is 8 bits and Short is 16 bits. 380 * 381 * _SUNOS_VTOC_8 / _SUNOS_VTOC_16 / _SVR4_VTOC_16: 382 * This specifies the form of the disk VTOC (or label): 383 * 384 * _SUNOS_VTOC_8: 385 * This is a VTOC form which is upwardly compatible with the 386 * SunOS 4.x disk label and allows 8 partitions per disk. 387 * 388 * _SUNOS_VTOC_16: 389 * In this format the incore vtoc image matches the ondisk 390 * version. It allows 16 slices per disk, and is not 391 * compatible with the SunOS 4.x disk label. 392 * 393 * Note that these are not the only two VTOC forms possible and 394 * additional forms may be added. One possible form would be the 395 * SVr4 VTOC form. The symbol for that is reserved now, although 396 * it is not implemented. 397 * 398 * _SVR4_VTOC_16: 399 * This VTOC form is compatible with the System V Release 4 400 * VTOC (as implemented on the SVr4 Intel and 3b ports) with 401 * 16 partitions per disk. 402 * 403 * 404 * _DMA_USES_PHYSADDR / _DMA_USES_VIRTADDR 405 * This describes the type of addresses used by system DMA: 406 * 407 * _DMA_USES_PHYSADDR: 408 * This type of DMA, used in the x86 implementation, 409 * requires physical addresses for DMA buffers. The 24-bit 410 * addresses used by some legacy boards is the source of the 411 * "low-memory" (<16MB) requirement for some devices using DMA. 412 * 413 * _DMA_USES_VIRTADDR: 414 * This method of DMA allows the use of virtual addresses for 415 * DMA transfers. 416 * 417 * _FIRMWARE_NEEDS_FDISK / _NO_FDISK_PRESENT 418 * This indicates the presence/absence of an fdisk table. 419 * 420 * _FIRMWARE_NEEDS_FDISK 421 * The fdisk table is required by system firmware. If present, 422 * it allows a disk to be subdivided into multiple fdisk 423 * partitions, each of which is equivalent to a separate, 424 * virtual disk. This enables the co-existence of multiple 425 * operating systems on a shared hard disk. 426 * 427 * _NO_FDISK_PRESENT 428 * If the fdisk table is absent, it is assumed that the entire 429 * media is allocated for a single operating system. 430 * 431 * _HAVE_TEM_FIRMWARE 432 * Defined if this architecture has the (fallback) option of 433 * using prom_* calls for doing I/O if a suitable kernel driver 434 * is not available to do it. 435 * 436 * _DONT_USE_1275_GENERIC_NAMES 437 * Controls whether or not device tree node names should 438 * comply with the IEEE 1275 "Generic Names" Recommended 439 * Practice. With _DONT_USE_GENERIC_NAMES, device-specific 440 * names identifying the particular device will be used. 441 * 442 * __i386_COMPAT 443 * This indicates whether the i386 ABI is supported as a *non-native* 444 * mode for the platform. When this symbol is defined: 445 * - 32-bit xstat-style system calls are enabled 446 * - 32-bit xmknod-style system calls are enabled 447 * - 32-bit system calls use i386 sizes -and- alignments 448 * 449 * Note that this is NOT defined for the i386 native environment! 450 * 451 * __x86 452 * This is ONLY a synonym for defined(__i386) || defined(__amd64) 453 * which is useful only insofar as these two architectures share 454 * common attributes. Analogous to __sparc. 455 * 456 * _PSM_MODULES 457 * This indicates whether or not the implementation uses PSM 458 * modules for processor support, reading /etc/mach from inside 459 * the kernel to extract a list. 460 * 461 * _RTC_CONFIG 462 * This indicates whether or not the implementation uses /etc/rtc_config 463 * to configure the real-time clock in the kernel. 464 * 465 * _UNIX_KRTLD 466 * This indicates that the implementation uses a dynamically 467 * linked unix + krtld to form the core kernel image at boot 468 * time, or (in the absence of this symbol) a prelinked kernel image. 469 * 470 * _OBP 471 * This indicates the firmware interface is OBP. 472 * 473 * _SOFT_HOSTID 474 * This indicates that the implementation obtains the hostid 475 * from the file /etc/hostid, rather than from hardware. 476 */ 477 478 479 480 481 482 /* 483 * The following set of definitions characterize Solaris on AMD's 484 * 64-bit systems. 485 */ 486 # 305 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/isa_defs.h" 487 /* 488 * Define the appropriate "processor characteristics" 489 */ 490 # 333 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/isa_defs.h" 491 /* 492 * Define the appropriate "implementation choices". 493 */ 494 # 351 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/isa_defs.h" 495 /* 496 * The following set of definitions characterize the Solaris on SPARC systems. 497 * 498 * The symbol __sparc indicates any of the SPARC family of processor 499 * architectures. This includes SPARC V7, SPARC V8 and SPARC V9. 500 * 501 * The symbol __sparcv8 indicates the 32-bit SPARC V8 architecture as defined 502 * by Version 8 of the SPARC Architecture Manual. (SPARC V7 is close enough 503 * to SPARC V8 for the former to be subsumed into the latter definition.) 504 * 505 * The symbol __sparcv9 indicates the 64-bit SPARC V9 architecture as defined 506 * by Version 9 of the SPARC Architecture Manual. 507 * 508 * The symbols __sparcv8 and __sparcv9 are mutually exclusive, and are only 509 * relevant when the symbol __sparc is defined. 510 */ 511 /* 512 * XXX Due to the existence of 5110166, "defined(__sparcv9)" needs to be added 513 * to support backwards builds. This workaround should be removed in s10_71. 514 */ 515 # 35 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 2 516 517 518 519 520 521 /* 522 * Values of _POSIX_C_SOURCE 523 * 524 * undefined not a POSIX compilation 525 * 1 POSIX.1-1990 compilation 526 * 2 POSIX.2-1992 compilation 527 * 199309L POSIX.1b-1993 compilation (Real Time) 528 * 199506L POSIX.1c-1995 compilation (POSIX Threads) 529 * 200112L POSIX.1-2001 compilation (Austin Group Revision) 530 * 200809L POSIX.1-2008 compilation 531 */ 532 533 534 535 536 /* 537 * The feature test macros __XOPEN_OR_POSIX, _STRICT_STDC, _STRICT_SYMBOLS, 538 * and _STDC_C99 are Sun implementation specific macros created in order to 539 * compress common standards specified feature test macros for easier reading. 540 * These macros should not be used by the application developer as 541 * unexpected results may occur. Instead, the user should reference 542 * standards(5) for correct usage of the standards feature test macros. 543 * 544 * __XOPEN_OR_POSIX Used in cases where a symbol is defined by both 545 * X/Open or POSIX or in the negative, when neither 546 * X/Open or POSIX defines a symbol. 547 * 548 * _STRICT_STDC __STDC__ is specified by the C Standards and defined 549 * by the compiler. For Sun compilers the value of 550 * __STDC__ is either 1, 0, or not defined based on the 551 * compilation mode (see cc(1)). When the value of 552 * __STDC__ is 1 and in the absence of any other feature 553 * test macros, the namespace available to the application 554 * is limited to only those symbols defined by the C 555 * Standard. _STRICT_STDC provides a more readable means 556 * of identifying symbols defined by the standard, or in 557 * the negative, symbols that are extensions to the C 558 * Standard. See additional comments for GNU C differences. 559 * 560 * _STDC_C99 __STDC_VERSION__ is specified by the C standards and 561 * defined by the compiler and indicates the version of 562 * the C standard. A value of 199901L indicates a 563 * compiler that complies with ISO/IEC 9899:1999, other- 564 * wise known as the C99 standard. 565 * 566 * _STDC_C11 Like _STDC_C99 except that the value of __STDC_VERSION__ 567 * is 201112L indicating a compiler that compiles with 568 * ISO/IEXC 9899:2011, otherwise known as the C11 standard. 569 * 570 * _STRICT_SYMBOLS Used in cases where symbol visibility is restricted 571 * by the standards, and the user has not explicitly 572 * relaxed the strictness via __EXTENSIONS__. 573 */ 574 575 576 577 578 579 /* 580 * ISO/IEC 9899:1990 and it's revisions, ISO/IEC 9899:1999 and ISO/IEC 581 * 99899:2011 specify the following predefined macro name: 582 * 583 * __STDC__ The integer constant 1, intended to indicate a conforming 584 * implementation. 585 * 586 * Furthermore, a strictly conforming program shall use only those features 587 * of the language and library specified in these standards. A conforming 588 * implementation shall accept any strictly conforming program. 589 * 590 * Based on these requirements, Sun's C compiler defines __STDC__ to 1 for 591 * strictly conforming environments and __STDC__ to 0 for environments that 592 * use ANSI C semantics but allow extensions to the C standard. For non-ANSI 593 * C semantics, Sun's C compiler does not define __STDC__. 594 * 595 * The GNU C project interpretation is that __STDC__ should always be defined 596 * to 1 for compilation modes that accept ANSI C syntax regardless of whether 597 * or not extensions to the C standard are used. Violations of conforming 598 * behavior are conditionally flagged as warnings via the use of the 599 * -pedantic option. In addition to defining __STDC__ to 1, the GNU C 600 * compiler also defines __STRICT_ANSI__ as a means of specifying strictly 601 * conforming environments using the -ansi or -std=<standard> options. 602 * 603 * In the absence of any other compiler options, Sun and GNU set the value 604 * of __STDC__ as follows when using the following options: 605 * 606 * Value of __STDC__ __STRICT_ANSI__ 607 * 608 * cc -Xa (default) 0 undefined 609 * cc -Xt (transitional) 0 undefined 610 * cc -Xc (strictly conforming) 1 undefined 611 * cc -Xs (K&R C) undefined undefined 612 * 613 * gcc (default) 1 undefined 614 * gcc -ansi, -std={c89, c99,...) 1 defined 615 * gcc -traditional (K&R) undefined undefined 616 * 617 * The default compilation modes for Sun C compilers versus GNU C compilers 618 * results in a differing value for __STDC__ which results in a more 619 * restricted namespace when using Sun compilers. To allow both GNU and Sun 620 * interpretations to peacefully co-exist, we use the following Sun 621 * implementation _STRICT_STDC_ macro: 622 */ 623 # 150 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 624 /* 625 * Compiler complies with ISO/IEC 9899:1999 or ISO/IEC 9989:2011 626 */ 627 # 162 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 628 /* 629 * Use strict symbol visibility. 630 */ 631 632 633 634 635 636 /* 637 * Large file interfaces: 638 * 639 * _LARGEFILE_SOURCE 640 * 1 large file-related additions to POSIX 641 * interfaces requested (fseeko, etc.) 642 * _LARGEFILE64_SOURCE 643 * 1 transitional large-file-related interfaces 644 * requested (seek64, stat64, etc.) 645 * 646 * The corresponding announcement macros are respectively: 647 * _LFS_LARGEFILE 648 * _LFS64_LARGEFILE 649 * (These are set in <unistd.h>.) 650 * 651 * Requesting _LARGEFILE64_SOURCE implies requesting _LARGEFILE_SOURCE as 652 * well. 653 * 654 * The large file interfaces are made visible regardless of the initial values 655 * of the feature test macros under certain circumstances: 656 * - If no explicit standards-conforming environment is requested (neither 657 * of _POSIX_SOURCE nor _XOPEN_SOURCE is defined and the value of 658 * __STDC__ does not imply standards conformance). 659 * - Extended system interfaces are explicitly requested (__EXTENSIONS__ 660 * is defined). 661 * - Access to in-kernel interfaces is requested (_KERNEL or _KMEMUSER is 662 * defined). (Note that this dependency is an artifact of the current 663 * kernel implementation and may change in future releases.) 664 */ 665 # 210 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 666 /* 667 * Large file compilation environment control: 668 * 669 * The setting of _FILE_OFFSET_BITS controls the size of various file-related 670 * types and governs the mapping between file-related source function symbol 671 * names and the corresponding binary entry points. 672 * 673 * In the 32-bit environment, the default value is 32; if not set, set it to 674 * the default here, to simplify tests in other headers. 675 * 676 * In the 64-bit compilation environment, the only value allowed is 64. 677 */ 678 # 238 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 679 /* 680 * Use of _XOPEN_SOURCE 681 * 682 * The following X/Open specifications are supported: 683 * 684 * X/Open Portability Guide, Issue 3 (XPG3) 685 * X/Open CAE Specification, Issue 4 (XPG4) 686 * X/Open CAE Specification, Issue 4, Version 2 (XPG4v2) 687 * X/Open CAE Specification, Issue 5 (XPG5) 688 * Open Group Technical Standard, Issue 6 (XPG6), also referred to as 689 * IEEE Std. 1003.1-2001 and ISO/IEC 9945:2002. 690 * Open Group Technical Standard, Issue 7 (XPG7), also referred to as 691 * IEEE Std. 1003.1-2008 and ISO/IEC 9945:2009. 692 * 693 * XPG4v2 is also referred to as UNIX 95 (SUS or SUSv1). 694 * XPG5 is also referred to as UNIX 98 or the Single Unix Specification, 695 * Version 2 (SUSv2) 696 * XPG6 is the result of a merge of the X/Open and POSIX specifications 697 * and as such is also referred to as IEEE Std. 1003.1-2001 in 698 * addition to UNIX 03 and SUSv3. 699 * XPG7 is also referred to as UNIX 08 and SUSv4. 700 * 701 * When writing a conforming X/Open application, as per the specification 702 * requirements, the appropriate feature test macros must be defined at 703 * compile time. These are as follows. For more info, see standards(5). 704 * 705 * Feature Test Macro Specification 706 * ------------------------------------------------ ------------- 707 * _XOPEN_SOURCE XPG3 708 * _XOPEN_SOURCE && _XOPEN_VERSION = 4 XPG4 709 * _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED = 1 XPG4v2 710 * _XOPEN_SOURCE = 500 XPG5 711 * _XOPEN_SOURCE = 600 (or POSIX_C_SOURCE=200112L) XPG6 712 * _XOPEN_SOURCE = 700 (or POSIX_C_SOURCE=200809L) XPG7 713 * 714 * In order to simplify the guards within the headers, the following 715 * implementation private test macros have been created. Applications 716 * must NOT use these private test macros as unexpected results will 717 * occur. 718 * 719 * Note that in general, the use of these private macros is cumulative. 720 * For example, the use of _XPG3 with no other restrictions on the X/Open 721 * namespace will make the symbols visible for XPG3 through XPG6 722 * compilation environments. The use of _XPG4_2 with no other X/Open 723 * namespace restrictions indicates that the symbols were introduced in 724 * XPG4v2 and are therefore visible for XPG4v2 through XPG6 compilation 725 * environments, but not for XPG3 or XPG4 compilation environments. 726 * 727 * _XPG3 X/Open Portability Guide, Issue 3 (XPG3) 728 * _XPG4 X/Open CAE Specification, Issue 4 (XPG4) 729 * _XPG4_2 X/Open CAE Specification, Issue 4, Version 2 (XPG4v2/UNIX 95/SUS) 730 * _XPG5 X/Open CAE Specification, Issue 5 (XPG5/UNIX 98/SUSv2) 731 * _XPG6 Open Group Technical Standard, Issue 6 (XPG6/UNIX 03/SUSv3) 732 * _XPG7 Open Group Technical Standard, Issue 7 (XPG7/UNIX 08/SUSv4) 733 */ 734 735 /* X/Open Portability Guide, Issue 3 */ 736 # 341 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 737 /* 738 * _XOPEN_VERSION is defined by the X/Open specifications and is not 739 * normally defined by the application, except in the case of an XPG4 740 * application. On the implementation side, _XOPEN_VERSION defined with 741 * the value of 3 indicates an XPG3 application. _XOPEN_VERSION defined 742 * with the value of 4 indicates an XPG4 or XPG4v2 (UNIX 95) application. 743 * _XOPEN_VERSION defined with a value of 500 indicates an XPG5 (UNIX 98) 744 * application and with a value of 600 indicates an XPG6 (UNIX 03) 745 * application and with a value of 700 indicates an XPG7 (UNIX 08). 746 * The appropriate version is determined by the use of the 747 * feature test macros described earlier. The value of _XOPEN_VERSION 748 * defaults to 3 otherwise indicating support for XPG3 applications. 749 */ 750 # 368 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 751 /* 752 * ANSI C and ISO 9899:1990 say the type long long doesn't exist in strictly 753 * conforming environments. ISO 9899:1999 says it does. 754 * 755 * The presence of _LONGLONG_TYPE says "long long exists" which is therefore 756 * defined in all but strictly conforming environments that disallow it. 757 */ 758 # 388 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 759 /* 760 * The following macro defines a value for the ISO C99 restrict 761 * keyword so that _RESTRICT_KYWD resolves to "restrict" if 762 * an ISO C99 compiler is used, "__restrict" for c++ and "" (null string) 763 * if any other compiler is used. This allows for the use of single 764 * prototype declarations regardless of compiler version. 765 */ 766 # 410 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/feature_tests.h" 767 /* 768 * The following macro defines a value for the ISO C11 _Noreturn 769 * keyword so that _NORETURN_KYWD resolves to "_Noreturn" if 770 * an ISO C11 compiler is used and "" (null string) if any other 771 * compiler is used. This allows for the use of single prototype 772 * declarations regardless of compiler version. 773 */ 774 775 776 777 778 779 780 781 /* 782 * The following macro indicates header support for the ANSI C++ 783 * standard. The ISO/IEC designation for this is ISO/IEC FDIS 14882. 784 */ 785 786 787 /* 788 * The following macro indicates header support for the C99 standard, 789 * ISO/IEC 9899:1999, Programming Languages - C. 790 */ 791 792 793 /* 794 * The following macro indicates header support for the C99 standard, 795 * ISO/IEC 9899:2011, Programming Languages - C. 796 */ 797 798 799 /* 800 * The following macro indicates header support for DTrace. The value is an 801 * integer that corresponds to the major version number for DTrace. 802 */ 803 # 50 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/iso/string_iso.h" 2 804 # 1 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/sys/null.h" 1 805 /* 806 * This file and its contents are supplied under the terms of the 807 * Common Development and Distribution License ("CDDL"), version 1.0. 808 * You may only use this file in accordance with the terms of version 809 * 1.0 of the CDDL. 810 * 811 * A full copy of the text of the CDDL should have accompanied this 812 * source. A copy of the CDDL is also available via the Internet at 813 * http://www.illumos.org/license/CDDL. 814 */ 815 816 /* 817 * Copyright 2014-2016 PALO, Richard. 818 */ 819 # 51 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/iso/string_iso.h" 2 820 # 65 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/iso/string_iso.h" 821 typedef unsigned int size_t; /* (historical version) */ 822 823 824 825 extern int memcmp(const void *, const void *, size_t); 826 extern void *memcpy(void *, const void *, size_t); 827 extern void *memmove(void *, const void *, size_t); 828 extern void *memset(void *, int, size_t); 829 extern char *strcat(char *, const char *); 830 extern int strcmp(const char *, const char *); 831 extern char *strcpy(char *, const char *); 832 extern int strcoll(const char *, const char *); 833 extern size_t strcspn(const char *, const char *); 834 extern char *strerror(int); 835 extern size_t strlen(const char *); 836 extern char *strncat(char *, const char *, size_t); 837 extern int strncmp(const char *, const char *, size_t); 838 extern char *strncpy(char *, const char *, size_t); 839 extern size_t strspn(const char *, const char *); 840 extern char *strtok(char *, const char *); 841 extern size_t strxfrm(char *, const char *, size_t); 842 843 /* 844 * The C++ Standard (ISO/IEC 14882:1998) specifies that each of the 845 * function signatures for the following functions be replaced by 846 * two declarations, both of which have the same behavior. 847 */ 848 # 139 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/iso/string_iso.h" 849 extern void *memchr(const void *, int, size_t); 850 extern char *strchr(const char *, int); 851 extern char *strpbrk(const char *, const char *); 852 extern char *strrchr(const char *, int); 853 extern char *strstr(const char *, const char *); 854 # 34 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/string.h" 2 855 856 /* 857 * Allow global visibility for symbols defined in 858 * C++ "std" namespace in <iso/string_iso.h>. 859 */ 860 # 72 "/home/git3/dehawe/titanic_53/proto/root_i386/usr/include/string.h" 861 extern int strerror_r(int, char *, size_t); 862 863 864 865 866 867 extern char *strtok_r(char *, const char *, 868 char **); 869 870 871 872 873 extern void *memccpy(void *, const void *, 874 int, size_t); 875 876 877 878 879 extern char *stpcpy(char *, const char *); 880 extern char *stpncpy(char *, const char *, size_t); 881 extern char *strndup(const char *, size_t); 882 extern size_t strnlen(const char *, size_t); 883 extern char *strsignal(int); 884 885 886 887 typedef struct _locale *locale_t; 888 889 890 extern int strcoll_l(const char *, const char *, locale_t); 891 extern size_t strxfrm_l(char *, const char *, 892 size_t, locale_t); 893 extern int strcasecmp_l(const char *, const char *, locale_t); 894 extern int strncasecmp_l(const char *, const char *, size_t, locale_t); 895 extern char *strerror_l(int, locale_t); 896 897 898 899 900 901 /* Note that some of these are also declared in strings.h for XPG4_2+ */ 902 extern void explicit_bzero(void *, size_t); 903 extern int uucopy(const void *, void *, size_t); 904 extern int uucopystr(const void *, void *, size_t); 905 extern int ffs(int); 906 extern int ffsl(long); 907 extern int ffsll(long long); 908 extern int fls(int); 909 extern int flsl(long); 910 extern int flsll(long long); 911 extern void *memmem(const void *, size_t, const void *, size_t); 912 extern char *strcasestr(const char *, const char *); 913 extern char *strnstr(const char *, const char *, size_t); 914 extern size_t strlcpy(char *, const char *, size_t); 915 extern size_t strlcat(char *, const char *, size_t); 916 extern char *strsep(char **stringp, const char *delim); 917 extern char *strchrnul(const char *, int); 918 extern char *strcasestr_l(const char *, const char *, locale_t); 919 extern int strcasecmp(const char *, const char *); 920 extern int strncasecmp(const char *, const char *, size_t); 921 922 923 924 925 926 extern char *strdup(const char *); 927 928 929 930 931 932 933 /* 934 * gcc provides this inlining facility but Studio C does not. 935 * We should use it exclusively once Studio C also provides it. 936 */ 937 extern void *__builtin_alloca(size_t); 938 # 30 "cvtpath.c" 2 939 940 extern char *root, *basedir; /* WHERE? */ 941 942 void 943 cvtpath(char *path, char *copy) 944 { 945 *copy++ = '/'; 946 if (root || (basedir && (*path != '/'))) { 947 if (root && ((basedir == 0) || (path[0] == '/') || 948 (basedir[0] != '/'))) { 949 /* look in root */ 950 (void) strcpy(copy, root + (*root == '/' ? 1 : 0)); 951 copy += strlen(copy); 952 if (copy[-1] != '/') 953 *copy++ = '/'; 954 } 955 if (basedir && (*path != '/')) { 956 (void) strcpy(copy, 957 basedir + (*basedir == '/' ? 1 : 0)); 958 copy += strlen(copy); 959 if (copy[-1] != '/') 960 *copy++ = '/'; 961 } 962 } 963 (void) strcpy(copy, path + (*path == '/' ? 1 : 0)); 964 } 965