Clownfish
view release on metacpan or search on metacpan
charmonizer.c view on Meta::CPAN
* On some systems, the second argument to makedir will be ignored, in which
* case this symbol will be true; otherwise, it will be false: (TODO: This
* isn't verified and may sometimes be incorrect.)
*
* MAKEDIR_MODE_IGNORED
*
* String representing the system's directory separator:
*
* DIR_SEP
*
* True if the remove() function removes directories, false otherwise:
*
* REMOVE_ZAPS_DIRS
*/
void chaz_DirManip_run(void);
#endif /* H_CHAZ_DIR_SEP */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/Floats.h"
/* Charmonizer/Probe/Floats.h -- floating point types.
*
* The following symbols will be created if the platform supports IEEE 754
* floating point types:
*
* F32_NAN
* F32_INF
* F32_NEGINF
* F64_NAN
* F64_INF
* F64_NEGINF
*
* TODO: Actually test to see whether IEEE 754 is supported, rather than just
* lying about it.
*/
#ifndef H_CHAZ_FLOATS
#define H_CHAZ_FLOATS
/* Run the Floats module.
*/
void
chaz_Floats_run(void);
/* Return the name of the math library to link against or NULL.
*/
const char*
chaz_Floats_math_library(void);
#endif /* H_CHAZ_FLOATS */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/FuncMacro.h"
/* Charmonizer/Probe/FuncMacro.h
*/
#ifndef H_CHAZ_FUNC_MACRO
#define H_CHAZ_FUNC_MACRO
#include <stdio.h>
/* Run the FuncMacro module.
*
* If __func__ successfully resolves, this will be defined:
*
* HAS_ISO_FUNC_MACRO
*
* If __FUNCTION__ successfully resolves, this will be defined:
*
* HAS_GNUC_FUNC_MACRO
*
* If one or the other succeeds, these will be defined:
*
* HAS_FUNC_MACRO
* FUNC_MACRO
*
* The "inline" keyword will also be probed for. If it is available, the
* following macro will be defined to "inline", otherwise it will be defined
* to nothing.
*
* INLINE
*/
void chaz_FuncMacro_run(void);
#endif /* H_CHAZ_FUNC_MACRO */
/***************************************************************************/
#line 20 "src/Charmonizer/Probe/Headers.h"
/* Charmonizer/Probe/Headers.h
*/
#ifndef H_CHAZ_HEADERS
#define H_CHAZ_HEADERS
#include <stdio.h>
/* #include "Charmonizer/Core/Defines.h" */
/* Check whether a particular header file is available. The test-compile is
* only run the first time a given request is made.
*/
int
chaz_Headers_check(const char *header_name);
/* Run the Headers module.
*
* Exported symbols:
*
* If HAS_C89 is declared, this system has all the header files described in
* Ansi C 1989. HAS_C90 is a synonym. (It would be surprising if they are
* not defined, because Charmonizer itself assumes C89.)
*
* HAS_C89
* HAS_C90
*
* One symbol is exported for each C89 header file:
*
* HAS_ASSERT_H
* HAS_CTYPE_H
* HAS_ERRNO_H
* HAS_FLOAT_H
* HAS_LIMITS_H
* HAS_LOCALE_H
* HAS_MATH_H
* HAS_SETJMP_H
* HAS_SIGNAL_H
* HAS_STDARG_H
* HAS_STDDEF_H
* HAS_STDIO_H
* HAS_STDLIB_H
* HAS_STRING_H
* HAS_TIME_H
*
* One symbol is exported for every POSIX header present, and HAS_POSIX is
* exported if they're all there.
*
* HAS_POSIX
*
* HAS_CPIO_H
* HAS_DIRENT_H
charmonizer.c view on Meta::CPAN
/* Charmonizer/Probe/Strings.h
*/
#ifndef H_CHAZ_STRINGS
#define H_CHAZ_STRINGS
/* The Strings module attempts to detect whether snprintf works as specified
* by the C99 standard. It also looks for system-specific functions which can
* be used to emulate snprintf.
*/
void chaz_Strings_run(void);
#endif /* H_CHAZ_STRINGS */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/SymbolVisibility.h"
/* Charmonizer/Probe/SymbolVisibility.h
*/
#ifndef H_CHAZ_SYMBOLVISIBILITY
#define H_CHAZ_SYMBOLVISIBILITY
void chaz_SymbolVisibility_run(void);
#endif /* H_CHAZ_SYMBOLVISIBILITY */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/UnusedVars.h"
/* Charmonizer/Probe/UnusedVars.h
*/
#ifndef H_CHAZ_UNUSED_VARS
#define H_CHAZ_UNUSED_VARS
#include <stdio.h>
/* Run the UnusedVars module.
*
* These symbols are exported:
*
* UNUSED_VAR(var)
* UNREACHABLE_RETURN(type)
*
*/
void chaz_UnusedVars_run(void);
#endif /* H_CHAZ_UNUSED_VARS */
/***************************************************************************/
#line 21 "src/Charmonizer/Probe/VariadicMacros.h"
/* Charmonizer/Probe/VariadicMacros.h
*/
#ifndef H_CHAZ_VARIADIC_MACROS
#define H_CHAZ_VARIADIC_MACROS
#include <stdio.h>
/* Run the VariadicMacros module.
*
* If your compiler supports ISO-style variadic macros, this will be defined:
*
* HAS_ISO_VARIADIC_MACROS
*
* If your compiler supports GNU-style variadic macros, this will be defined:
*
* HAS_GNUC_VARIADIC_MACROS
*
* If you have at least one of the above, this will be defined:
*
* HAS_VARIADIC_MACROS
*/
void chaz_VariadicMacros_run(void);
#endif /* H_CHAZ_VARIADIC_MACROS */
/***************************************************************************/
#line 17 "src/Charmonizer/Core/CFlags.c"
#include <string.h>
#include <stdlib.h>
/* #include "Charmonizer/Core/CFlags.h" */
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Core/OperatingSystem.h" */
struct chaz_CFlags {
int style;
char *string;
};
chaz_CFlags*
chaz_CFlags_new(int style) {
chaz_CFlags *flags = (chaz_CFlags*)malloc(sizeof(chaz_CFlags));
flags->style = style;
flags->string = chaz_Util_strdup("");
return flags;
}
void
chaz_CFlags_destroy(chaz_CFlags *flags) {
free(flags->string);
free(flags);
}
const char*
chaz_CFlags_get_string(chaz_CFlags *flags) {
return flags->string;
}
void
chaz_CFlags_append(chaz_CFlags *flags, const char *string) {
char *new_string;
if (flags->string[0] == '\0') {
new_string = chaz_Util_strdup(string);
}
else {
new_string = chaz_Util_join(" ", flags->string, string, NULL);
}
free(flags->string);
flags->string = new_string;
}
void
chaz_CFlags_clear(chaz_CFlags *flags) {
if (flags->string[0] != '\0') {
free(flags->string);
flags->string = chaz_Util_strdup("");
}
}
charmonizer.c view on Meta::CPAN
" = { { 0, 0, 0x80, 0x7F } };\n"
"static const chy_floatu32 chy_f32neginf\n"
" = { { 0, 0, 0x80, 0xFF } };\n"
"static const chy_floatu32 chy_f32nan\n"
" = { { 0, 0, 0xC0, 0x7F } };\n"
"static const chy_floatu64 chy_f64inf\n"
" = { { 0, 0, 0, 0, 0, 0, 0xF0, 0x7F } };\n"
"static const chy_floatu64 chy_f64neginf\n"
" = { { 0, 0, 0, 0, 0, 0, 0xF0, 0xFF } };\n"
"static const chy_floatu64 chy_f64nan\n"
" = { { 0, 0, 0, 0, 0, 0, 0xF8, 0x7F } };\n"
"#endif /* BIG_END */\n"
);
chaz_ConfWriter_add_def("F32_INF", "(chy_f32inf.f)");
chaz_ConfWriter_add_def("F32_NEGINF", "(chy_f32neginf.f)");
chaz_ConfWriter_add_def("F32_NAN", "(chy_f32nan.f)");
chaz_ConfWriter_add_def("F64_INF", "(chy_f64inf.d)");
chaz_ConfWriter_add_def("F64_NEGINF", "(chy_f64neginf.d)");
chaz_ConfWriter_add_def("F64_NAN", "(chy_f64nan.d)");
chaz_ConfWriter_end_module();
}
const char*
chaz_Floats_math_library(void) {
static const char sqrt_code[] =
CHAZ_QUOTE( #include <math.h> )
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( typedef double (*sqrt_t)(double); )
CHAZ_QUOTE( int main(void) { )
CHAZ_QUOTE( printf("%p\n", (sqrt_t)sqrt); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
chaz_CFlags *temp_cflags = chaz_CC_get_temp_cflags();
char *output = NULL;
size_t output_len;
output = chaz_CC_capture_output(sqrt_code, &output_len);
if (output != NULL) {
/* Linking against libm not needed. */
free(output);
return NULL;
}
chaz_CFlags_add_external_lib(temp_cflags, "m");
output = chaz_CC_capture_output(sqrt_code, &output_len);
chaz_CFlags_clear(temp_cflags);
if (output == NULL) {
chaz_Util_die("Don't know how to use math library.");
}
free(output);
return "m";
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/FuncMacro.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/FuncMacro.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Probe for ISO func macro. */
static int
chaz_FuncMacro_probe_iso() {
static const char iso_func_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%s", __func__); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
size_t output_len;
char *output;
int success = false;
output = chaz_CC_capture_output(iso_func_code, &output_len);
if (output != NULL && strncmp(output, "main", 4) == 0) {
success = true;
}
free(output);
return success;
}
static int
chaz_FuncMacro_probe_gnu() {
/* Code for verifying GNU func macro. */
static const char gnu_func_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%s", __FUNCTION__); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
size_t output_len;
char *output;
int success = false;
output = chaz_CC_capture_output(gnu_func_code, &output_len);
if (output != NULL && strncmp(output, "main", 4) == 0) {
success = true;
}
free(output);
return success;
}
/* Attempt to verify inline keyword. */
static char*
chaz_FuncMacro_try_inline(const char *keyword, size_t *output_len) {
static const char inline_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( static %s int foo() { return 1; } )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( printf("%%d", foo()); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
char code[sizeof(inline_code) + 30];
sprintf(code, inline_code, keyword);
return chaz_CC_capture_output(code, output_len);
}
static void
chaz_FuncMacro_probe_inline(void) {
static const char* inline_options[] = {
"__inline",
"__inline__",
"inline"
};
const int num_inline_options = sizeof(inline_options) / sizeof(void*);
int has_inline = false;
int i;
for (i = 0; i < num_inline_options; i++) {
const char *inline_option = inline_options[i];
size_t output_len;
char *output = chaz_FuncMacro_try_inline(inline_option, &output_len);
if (output != NULL) {
has_inline = true;
chaz_ConfWriter_add_def("INLINE", inline_option);
free(output);
break;
}
}
if (!has_inline) {
chaz_ConfWriter_add_def("INLINE", NULL);
}
}
void
chaz_FuncMacro_run(void) {
int has_funcmac = false;
int has_iso_funcmac = false;
int has_gnuc_funcmac = false;
chaz_ConfWriter_start_module("FuncMacro");
/* Check for func macros. */
if (chaz_FuncMacro_probe_iso()) {
has_funcmac = true;
has_iso_funcmac = true;
}
if (chaz_FuncMacro_probe_gnu()) {
has_funcmac = true;
has_gnuc_funcmac = true;
}
/* Write out common defines. */
if (has_funcmac) {
const char *macro_text = has_iso_funcmac
? "__func__"
: "__FUNCTION__";
chaz_ConfWriter_add_def("HAS_FUNC_MACRO", NULL);
chaz_ConfWriter_add_def("FUNC_MACRO", macro_text);
}
/* Write out specific defines. */
if (has_iso_funcmac) {
chaz_ConfWriter_add_def("HAS_ISO_FUNC_MACRO", NULL);
}
if (has_gnuc_funcmac) {
chaz_ConfWriter_add_def("HAS_GNUC_FUNC_MACRO", NULL);
}
/* Check for inline keyword. */
chaz_FuncMacro_probe_inline();
chaz_ConfWriter_end_module();
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/Headers.c"
/* #include "Charmonizer/Core/HeaderChecker.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/Headers.h" */
#include <ctype.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#define CHAZ_HEADERS_MAX_KEEPERS 200
static struct {
int keeper_count;
const char *keepers[CHAZ_HEADERS_MAX_KEEPERS + 1];
} chaz_Headers = { 0, { NULL } };
/* Add a header to the keepers array.
*/
static void
chaz_Headers_keep(const char *header_name);
/* Transform "header.h" into "CHY_HAS_HEADER_H, storing the result into
* `buffer`.
*/
static void
chaz_Headers_encode_affirmation(const char *header_name, char *buffer,
size_t buf_size);
/* Probe for all C89 headers. */
static void
chaz_Headers_probe_c89(void);
/* Probe for all POSIX headers. */
static void
chaz_Headers_probe_posix(void);
/* Prove for selected Windows headers. */
static void
chaz_Headers_probe_win(void);
int
chaz_Headers_check(const char *header_name) {
return chaz_HeadCheck_check_header(header_name);
}
void
chaz_Headers_run(void) {
int i;
charmonizer.c view on Meta::CPAN
*/
chaz_ConfWriter_add_def("IMPORT", NULL);
}
else {
chaz_ConfWriter_add_def("IMPORT", "__declspec(dllimport)");
}
}
}
/* GCC. */
if (!can_control_visibility) {
char export_gcc[] = "__attribute__ ((visibility (\"default\")))";
sprintf(code_buf, chaz_SymbolVisibility_symbol_exporting_code,
export_gcc);
if (chaz_CC_test_compile(code_buf)) {
can_control_visibility = true;
chaz_ConfWriter_add_def("EXPORT", export_gcc);
chaz_ConfWriter_add_def("IMPORT", NULL);
}
}
chaz_CFlags_clear(temp_cflags);
/* Default. */
if (!can_control_visibility) {
chaz_ConfWriter_add_def("EXPORT", NULL);
chaz_ConfWriter_add_def("IMPORT", NULL);
}
chaz_ConfWriter_end_module();
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/UnusedVars.c"
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/UnusedVars.h" */
#include <string.h>
#include <stdio.h>
void
chaz_UnusedVars_run(void) {
chaz_ConfWriter_start_module("UnusedVars");
/* Write the macros (no test, these are the same everywhere). */
chaz_ConfWriter_add_def("UNUSED_VAR(x)", "((void)x)");
chaz_ConfWriter_add_def("UNREACHABLE_RETURN(type)", "return (type)0");
chaz_ConfWriter_end_module();
}
/***************************************************************************/
#line 17 "src/Charmonizer/Probe/VariadicMacros.c"
/* #include "Charmonizer/Core/Compiler.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/Util.h" */
/* #include "Charmonizer/Probe/VariadicMacros.h" */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/* Code for verifying ISO-style variadic macros. */
static const char chaz_VariadicMacros_iso_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( #define ISO_TEST(fmt, ...) \\ )
" printf(fmt, __VA_ARGS__) \n"
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( ISO_TEST("%d %d", 1, 1); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
/* Code for verifying GNU-style variadic macros. */
static const char chaz_VariadicMacros_gnuc_code[] =
CHAZ_QUOTE( #include <stdio.h> )
CHAZ_QUOTE( #define GNU_TEST(fmt, args...) printf(fmt, ##args) )
CHAZ_QUOTE( int main() { )
CHAZ_QUOTE( GNU_TEST("%d %d", 1, 1); )
CHAZ_QUOTE( return 0; )
CHAZ_QUOTE( } );
void
chaz_VariadicMacros_run(void) {
char *output;
size_t output_len;
int has_varmacros = false;
chaz_ConfWriter_start_module("VariadicMacros");
/* Test for ISO-style variadic macros. */
output = chaz_CC_capture_output(chaz_VariadicMacros_iso_code, &output_len);
if (output != NULL) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
chaz_ConfWriter_add_def("HAS_ISO_VARIADIC_MACROS", NULL);
free(output);
}
/* Test for GNU-style variadic macros. */
output = chaz_CC_capture_output(chaz_VariadicMacros_gnuc_code, &output_len);
if (output != NULL) {
if (has_varmacros == false) {
has_varmacros = true;
chaz_ConfWriter_add_def("HAS_VARIADIC_MACROS", NULL);
}
chaz_ConfWriter_add_def("HAS_GNUC_VARIADIC_MACROS", NULL);
free(output);
}
chaz_ConfWriter_end_module();
}
#line 1 "runtime/common/charmonizer.main"
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Source fragment for the Clownfish runtime's charmonizer.c.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* #include "Charmonizer/Probe.h" */
/* #include "Charmonizer/Probe/AtomicOps.h" */
/* #include "Charmonizer/Probe/BuildEnv.h" */
/* #include "Charmonizer/Probe/DirManip.h" */
/* #include "Charmonizer/Probe/Floats.h" */
/* #include "Charmonizer/Probe/FuncMacro.h" */
/* #include "Charmonizer/Probe/Headers.h" */
/* #include "Charmonizer/Probe/Integers.h" */
/* #include "Charmonizer/Probe/LargeFiles.h" */
/* #include "Charmonizer/Probe/Memory.h" */
/* #include "Charmonizer/Probe/SymbolVisibility.h" */
/* #include "Charmonizer/Probe/VariadicMacros.h" */
/* #include "Charmonizer/Core/HeaderChecker.h" */
/* #include "Charmonizer/Core/CLI.h" */
/* #include "Charmonizer/Core/ConfWriter.h" */
/* #include "Charmonizer/Core/ConfWriterC.h" */
/* #include "Charmonizer/Core/ConfWriterPerl.h" */
/* #include "Charmonizer/Core/ConfWriterRuby.h" */
typedef struct cfish_MakeFile {
chaz_MakeFile *makefile;
chaz_MakeBinary *lib;
chaz_MakeBinary *test_lib;
chaz_MakeVar *cfh_var;
chaz_CLI *cli;
/* Directories and files. */
const char *base_dir;
const char *host_src_dir;
char *core_dir;
char *test_dir;
char *autogen_src_dir;
char *autogen_inc_dir;
char *autogen_target;
} cfish_MakeFile;
static const char cfish_version[] = "0.6.3";
static const char cfish_major_version[] = "0.6";
static void
S_add_compiler_flags(struct chaz_CLI *cli);
static chaz_CFlags*
S_link_flags(chaz_CLI *cli);
static cfish_MakeFile*
cfish_MakeFile_new(chaz_CLI *cli);
static void
cfish_MakeFile_destroy(cfish_MakeFile *self);
static void
cfish_MakeFile_write(cfish_MakeFile *self, chaz_CFlags *extra_link_flags);
static void
cfish_MakeFile_write_c_cfc_rules(cfish_MakeFile *self);
static void
cfish_MakeFile_write_c_test_rules(cfish_MakeFile *self);
static void
S_cfh_file_callback(const char *dir, char *file, void *context);
static int
S_ends_with(const char *string, const char *postfix);
static int
S_need_libpthread(chaz_CLI *cli);
int main(int argc, const char **argv) {
chaz_CFlags *link_flags;
/* Initialize. */
chaz_CLI *cli
= chaz_CLI_new(argv[0], "charmonizer: Probe C build environment");
chaz_CLI_register(cli, "host", "specify host binding language",
CHAZ_CLI_ARG_REQUIRED);
chaz_CLI_register(cli, "disable-threads", "whether to disable threads",
CHAZ_CLI_NO_ARG);
chaz_CLI_set_usage(cli, "Usage: charmonizer [OPTIONS] [-- [CFLAGS]]");
if (!chaz_Probe_parse_cli_args(argc, argv, cli)) {
chaz_Probe_die_usage();
}
if (!chaz_CLI_defined(cli, "host")) {
chaz_CLI_set(cli, "host", "c");
}
chaz_Probe_init(cli);
S_add_compiler_flags(cli);
/* Employ integer features but don't define stdint types in charmony.h. */
chaz_ConfWriter_append_conf(
"#define CHY_EMPLOY_INTEGERLIMITS\n"
"#define CHY_EMPLOY_INTEGERLITERALS\n"
"#define CHY_EMPLOY_INTEGERFORMATSTRINGS\n\n"
);
/* Run probe modules. Booleans, DirManip and LargeFiles are only needed for
* the Charmonizer tests.
*/
chaz_BuildEnv_run();
chaz_DirManip_run();
chaz_Headers_run();
chaz_AtomicOps_run();
chaz_FuncMacro_run();
chaz_Booleans_run();
chaz_Integers_run();
chaz_Floats_run();
chaz_LargeFiles_run();
chaz_Memory_run();
chaz_VariadicMacros_run();
/* Local definitions. */
chaz_ConfWriter_start_module("LocalDefinitions");
if (chaz_HeadCheck_defines_symbol("__sync_bool_compare_and_swap", "")) {
chaz_ConfWriter_add_def("HAS___SYNC_BOOL_COMPARE_AND_SWAP", NULL);
}
link_flags = S_link_flags(cli);
chaz_ConfWriter_add_def("EXTRA_LDFLAGS",
chaz_CFlags_get_string(link_flags));
chaz_ConfWriter_end_module();
/* Write custom postamble. */
chaz_ConfWriter_append_conf(
"#ifdef CHY_HAS_SYS_TYPES_H\n"
" #include <sys/types.h>\n"
"#endif\n\n"
);
chaz_ConfWriter_append_conf(
"#ifdef CHY_HAS_ALLOCA_H\n"
" #include <alloca.h>\n"
"#elif defined(CHY_HAS_MALLOC_H)\n"
" #include <malloc.h>\n"
"#elif defined(CHY_ALLOCA_IN_STDLIB_H)\n"
" #include <stdlib.h>\n"
"#endif\n\n"
);
chaz_ConfWriter_append_conf(
"#ifdef CHY_HAS_WINDOWS_H\n"
" /* Target Windows XP. */\n"
" #ifndef WINVER\n"
" #define WINVER 0x0500\n"
" #endif\n"
" #ifndef _WIN32_WINNT\n"
" #define _WIN32_WINNT 0x0500\n"
" #endif\n"
"#endif\n\n"
);
if (chaz_CLI_defined(cli, "enable-makefile")) {
cfish_MakeFile *mf = cfish_MakeFile_new(cli);
cfish_MakeFile_write(mf, link_flags);
cfish_MakeFile_destroy(mf);
}
/* Clean up. */
chaz_CFlags_destroy(link_flags);
chaz_CLI_destroy(cli);
chaz_Probe_clean_up();
return 0;
}
static void
S_add_compiler_flags(struct chaz_CLI *cli) {
chaz_CFlags *extra_cflags = chaz_CC_get_extra_cflags();
if (chaz_Probe_gcc_version_num()) {
if (!chaz_CC_is_mingw()) {
/* When using the MSVCRT, -pedantic complains about %I64 format
* specifiers.
( run in 0.398 second using v1.01-cache-2.11-cpan-ceb78f64989 )