From f966f693ea82f1a430de8ea07a1c855dffbe6186 Mon Sep 17 00:00:00 2001 From: WDrijver Date: Fri, 27 Dec 2024 12:25:27 +0100 Subject: [PATCH 1/5] Updated GitIgnore --- .gitignore | 5 + developer/demos/images/ArrowDown0.h | 40 ++ developer/demos/images/ArrowDown1.h | 40 ++ developer/demos/images/ArrowLeft0.h | 50 ++ developer/demos/images/ArrowLeft1.h | 50 ++ developer/demos/images/ArrowRight0.h | 50 ++ developer/demos/images/ArrowRight1.h | 50 ++ developer/demos/images/ArrowUp0.h | 40 ++ developer/demos/images/ArrowUp1.h | 40 ++ developer/demos/images/ImageButton0.h | 78 ++++ developer/demos/images/ImageButton1.h | 78 ++++ external/openurl/prefs/locale.h | 436 ++++++++++++++++++ rom/hidds/pci/pcitool/strings.h | 220 +++++++++ workbench/c/R/strings.h | 130 ++++++ .../classes/zune/nlist/nlisttree_mcp/locale.c | 156 +++++++ .../classes/zune/nlist/nlisttree_mcp/locale.h | 191 ++++++++ .../zune/nlist/nlistviews_mcp/locale.c | 226 +++++++++ .../zune/nlist/nlistviews_mcp/locale.h | 328 +++++++++++++ workbench/devs/diskimage/device/strings.h | 157 +++++++ workbench/devs/diskimage/zune_gui/strings.h | 225 +++++++++ workbench/libs/muimaster/muimaster_strings.h | 237 ++++++++++ workbench/prefs/appearance/strings.h | 130 ++++++ workbench/prefs/boingiconbar/strings.h | 118 +++++ workbench/prefs/printer/strings.h | 244 ++++++++++ workbench/system/find/strings.h | 169 +++++++ workbench/tools/BoingIconBar/strings.h | 100 ++++ workbench/tools/InstallAROS/strings.h | 355 ++++++++++++++ workbench/tools/SysExplorer/strings.h | 214 +++++++++ workbench/tools/WiMP/strings.h | 343 ++++++++++++++ 29 files changed, 4500 insertions(+) create mode 100644 developer/demos/images/ArrowDown0.h create mode 100644 developer/demos/images/ArrowDown1.h create mode 100644 developer/demos/images/ArrowLeft0.h create mode 100644 developer/demos/images/ArrowLeft1.h create mode 100644 developer/demos/images/ArrowRight0.h create mode 100644 developer/demos/images/ArrowRight1.h create mode 100644 developer/demos/images/ArrowUp0.h create mode 100644 developer/demos/images/ArrowUp1.h create mode 100644 developer/demos/images/ImageButton0.h create mode 100644 developer/demos/images/ImageButton1.h create mode 100644 external/openurl/prefs/locale.h create mode 100644 rom/hidds/pci/pcitool/strings.h create mode 100644 workbench/c/R/strings.h create mode 100644 workbench/classes/zune/nlist/nlisttree_mcp/locale.c create mode 100644 workbench/classes/zune/nlist/nlisttree_mcp/locale.h create mode 100644 workbench/classes/zune/nlist/nlistviews_mcp/locale.c create mode 100644 workbench/classes/zune/nlist/nlistviews_mcp/locale.h create mode 100644 workbench/devs/diskimage/device/strings.h create mode 100644 workbench/devs/diskimage/zune_gui/strings.h create mode 100644 workbench/libs/muimaster/muimaster_strings.h create mode 100644 workbench/prefs/appearance/strings.h create mode 100644 workbench/prefs/boingiconbar/strings.h create mode 100644 workbench/prefs/printer/strings.h create mode 100644 workbench/system/find/strings.h create mode 100644 workbench/tools/BoingIconBar/strings.h create mode 100644 workbench/tools/InstallAROS/strings.h create mode 100644 workbench/tools/SysExplorer/strings.h create mode 100644 workbench/tools/WiMP/strings.h diff --git a/.gitignore b/.gitignore index 199b905d496..0b740689d61 100644 --- a/.gitignore +++ b/.gitignore @@ -2130,3 +2130,8 @@ # /workbench/utilities/Presenter/ /workbench/utilities/Presenter/mmakefile +config/features.status +config/config.log +compiler/include/geninc.cfg +bin/Sources/.freetype-2.10.0-fetched +aros.rom diff --git a/developer/demos/images/ArrowDown0.h b/developer/demos/images/ArrowDown0.h new file mode 100644 index 00000000000..4496480e9a1 --- /dev/null +++ b/developer/demos/images/ArrowDown0.h @@ -0,0 +1,40 @@ +#define ARROWDOWN0_WIDTH 18 +#define ARROWDOWN0_HEIGHT 11 + +UBYTE ArrowDown0Data[] = +{ + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x0C, 0x0C, 0x40, 0x00, + 0x07, 0x38, 0x40, 0x00, + 0x03, 0xF0, 0x40, 0x00, + 0x01, 0xE0, 0x40, 0x00, + 0x00, 0xC0, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x7F, 0xFF, 0xC0, 0x00, + + 0xFF, 0xFF, 0x80, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, +}; + +struct Image ArrowDown0Image = +{ + 0, 0, /* Left, Top */ + ARROWDOWN0_WIDTH, ARROWDOWN0_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowDown0Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowDown1.h b/developer/demos/images/ArrowDown1.h new file mode 100644 index 00000000000..467f000be82 --- /dev/null +++ b/developer/demos/images/ArrowDown1.h @@ -0,0 +1,40 @@ +#define ARROWDOWN1_WIDTH 18 +#define ARROWDOWN1_HEIGHT 11 + +UBYTE ArrowDown1Data[] = +{ + 0xFF, 0xFF, 0x80, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x8C, 0x0C, 0x00, 0x00, + 0x87, 0x38, 0x00, 0x00, + 0x83, 0xF0, 0x00, 0x00, + 0x81, 0xE0, 0x00, 0x00, + 0x80, 0xC0, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x7F, 0xFF, 0xC0, 0x00, +}; + +struct Image ArrowDown1Image = +{ + 0, 0, /* Left, Top */ + ARROWDOWN1_WIDTH, ARROWDOWN1_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowDown1Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowLeft0.h b/developer/demos/images/ArrowLeft0.h new file mode 100644 index 00000000000..8bf9dad2c2f --- /dev/null +++ b/developer/demos/images/ArrowLeft0.h @@ -0,0 +1,50 @@ +#define ARROWLEFT0_WIDTH 11 +#define ARROWLEFT0_HEIGHT 16 + +UBYTE ArrowLeft0Data[] = +{ + 0x00, 0x00, + 0x00, 0x20, + 0x00, 0x20, + 0x01, 0x20, + 0x03, 0x20, + 0x06, 0x20, + 0x0E, 0x20, + 0x1C, 0x20, + 0x1C, 0x20, + 0x0E, 0x20, + 0x06, 0x20, + 0x03, 0x20, + 0x01, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0xFF, 0xE0, + + 0xFF, 0xE0, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x00, 0x00, +}; + +struct Image ArrowLeft0Image = +{ + 0, 0, /* Left, Top */ + ARROWLEFT0_WIDTH, ARROWLEFT0_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowLeft0Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowLeft1.h b/developer/demos/images/ArrowLeft1.h new file mode 100644 index 00000000000..03b5a6953b4 --- /dev/null +++ b/developer/demos/images/ArrowLeft1.h @@ -0,0 +1,50 @@ +#define ARROWLEFT1_WIDTH 11 +#define ARROWLEFT1_HEIGHT 16 + +UBYTE ArrowLeft1Data[] = +{ + 0xFF, 0xE0, + 0x80, 0x00, + 0x80, 0x00, + 0x81, 0x00, + 0x83, 0x00, + 0x86, 0x00, + 0x8E, 0x00, + 0x9C, 0x00, + 0x9C, 0x00, + 0x8E, 0x00, + 0x86, 0x00, + 0x83, 0x00, + 0x81, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x00, 0x00, + + 0x00, 0x00, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0xFF, 0xE0, +}; + +struct Image ArrowLeft1Image = +{ + 0, 0, /* Left, Top */ + ARROWLEFT1_WIDTH, ARROWLEFT1_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowLeft1Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowRight0.h b/developer/demos/images/ArrowRight0.h new file mode 100644 index 00000000000..3be7a12a986 --- /dev/null +++ b/developer/demos/images/ArrowRight0.h @@ -0,0 +1,50 @@ +#define ARROWRIGHT0_WIDTH 11 +#define ARROWRIGHT0_HEIGHT 16 + +UBYTE ArrowRight0Data[] = +{ + 0x00, 0x00, + 0x00, 0x20, + 0x00, 0x20, + 0x10, 0x20, + 0x18, 0x20, + 0x0C, 0x20, + 0x0E, 0x20, + 0x07, 0x20, + 0x07, 0x20, + 0x0E, 0x20, + 0x0C, 0x20, + 0x18, 0x20, + 0x10, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0xFF, 0xE0, + + 0xFF, 0xE0, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x00, 0x00, +}; + +struct Image ArrowRight0Image = +{ + 0, 0, /* Left, Top */ + ARROWRIGHT0_WIDTH, ARROWRIGHT0_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowRight0Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowRight1.h b/developer/demos/images/ArrowRight1.h new file mode 100644 index 00000000000..d7f4bf0bc12 --- /dev/null +++ b/developer/demos/images/ArrowRight1.h @@ -0,0 +1,50 @@ +#define ARROWRIGHT1_WIDTH 11 +#define ARROWRIGHT1_HEIGHT 16 + +UBYTE ArrowRight1Data[] = +{ + 0xFF, 0xE0, + 0x80, 0x00, + 0x80, 0x00, + 0x90, 0x00, + 0x98, 0x00, + 0x8C, 0x00, + 0x8E, 0x00, + 0x87, 0x00, + 0x87, 0x00, + 0x8E, 0x00, + 0x8C, 0x00, + 0x98, 0x00, + 0x90, 0x00, + 0x80, 0x00, + 0x80, 0x00, + 0x00, 0x00, + + 0x00, 0x00, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0x00, 0x20, + 0xFF, 0xE0, +}; + +struct Image ArrowRight1Image = +{ + 0, 0, /* Left, Top */ + ARROWRIGHT1_WIDTH, ARROWRIGHT1_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowRight1Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowUp0.h b/developer/demos/images/ArrowUp0.h new file mode 100644 index 00000000000..98c4e174bc3 --- /dev/null +++ b/developer/demos/images/ArrowUp0.h @@ -0,0 +1,40 @@ +#define ARROWUP0_WIDTH 18 +#define ARROWUP0_HEIGHT 11 + +UBYTE ArrowUp0Data[] = +{ + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0xC0, 0x40, 0x00, + 0x01, 0xE0, 0x40, 0x00, + 0x03, 0xF0, 0x40, 0x00, + 0x07, 0x38, 0x40, 0x00, + 0x0C, 0x0C, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x7F, 0xFF, 0xC0, 0x00, + + 0xFF, 0xFF, 0x80, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, +}; + +struct Image ArrowUp0Image = +{ + 0, 0, /* Left, Top */ + ARROWUP0_WIDTH, ARROWUP0_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowUp0Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ArrowUp1.h b/developer/demos/images/ArrowUp1.h new file mode 100644 index 00000000000..525b1d8180e --- /dev/null +++ b/developer/demos/images/ArrowUp1.h @@ -0,0 +1,40 @@ +#define ARROWUP1_WIDTH 18 +#define ARROWUP1_HEIGHT 11 + +UBYTE ArrowUp1Data[] = +{ + 0xFF, 0xFF, 0x80, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0xC0, 0x00, 0x00, + 0x81, 0xE0, 0x00, 0x00, + 0x83, 0xF0, 0x00, 0x00, + 0x87, 0x38, 0x00, 0x00, + 0x8C, 0x0C, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + 0x80, 0x00, 0x00, 0x00, + + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x40, 0x00, + 0x7F, 0xFF, 0xC0, 0x00, +}; + +struct Image ArrowUp1Image = +{ + 0, 0, /* Left, Top */ + ARROWUP1_WIDTH, ARROWUP1_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ArrowUp1Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ImageButton0.h b/developer/demos/images/ImageButton0.h new file mode 100644 index 00000000000..7f137051df1 --- /dev/null +++ b/developer/demos/images/ImageButton0.h @@ -0,0 +1,78 @@ +#define IMAGEBUTTON0_WIDTH 100 +#define IMAGEBUTTON0_HEIGHT 30 + +UBYTE ImageButton0Data[] = +{ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, + 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, + 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, + + 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, + 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, + 0x30, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, + 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x62, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +struct Image ImageButton0Image = +{ + 0, 0, /* Left, Top */ + IMAGEBUTTON0_WIDTH, IMAGEBUTTON0_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ImageButton0Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/developer/demos/images/ImageButton1.h b/developer/demos/images/ImageButton1.h new file mode 100644 index 00000000000..0ce3afc0528 --- /dev/null +++ b/developer/demos/images/ImageButton1.h @@ -0,0 +1,78 @@ +#define IMAGEBUTTON1_WIDTH 100 +#define IMAGEBUTTON1_HEIGHT 30 + +UBYTE ImageButton1Data[] = +{ + 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, + 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, + 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xC0, 0x00, + 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, + 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00, +}; + +struct Image ImageButton1Image = +{ + 0, 0, /* Left, Top */ + IMAGEBUTTON1_WIDTH, IMAGEBUTTON1_HEIGHT, /* Width, Height */ + 2, /* Depth */ + (UWORD *)ImageButton1Data, /* ImageData */ + 0x03, /* PlanePick */ + 0x00, /* PlaneOnOff */ + NULL /* NextImage */ +}; diff --git a/external/openurl/prefs/locale.h b/external/openurl/prefs/locale.h new file mode 100644 index 00000000000..33e984e5e31 --- /dev/null +++ b/external/openurl/prefs/locale.h @@ -0,0 +1,436 @@ +/*************************************************************************** + + openurl.library - universal URL display and browser launcher library + Copyright (C) 1998-2005 by Troels Walsted Hansen, et al. + Copyright (C) 2005-2013 by openurl.library Open Source Team + + This library is free software; it has been placed in the public domain + and you can freely redistribute it and/or modify it. Please note, however, + that some components may be under the LGPL or GPL license. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + openurl.library project: http://sourceforge.net/projects/openurllib/ + + $Id: locale_h.sd 195 2013-02-20 20:48:34Z thboeckel $ + +***************************************************************************/ + +/* +** This file was created automatically by flexcat. +** It is written to be compatible with catcomp, +** so you choose, but... Do NOT edit by hand! +**/ + +#ifndef _LOC_H +#define _LOC_H + +#ifndef EXEC_TYPES_H +#include +#endif + +#ifdef CATCOMP_ARRAY +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +/****************************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_ErrReqTitle 1 +#define MSG_ErrReqGadget 2 +#define MSG_Err_NoMem 3 +#define MSG_Err_NoMUI 4 +#define MSG_Err_NoIntuition 5 +#define MSG_Err_NoUtility 6 +#define MSG_Err_NoGfx 7 +#define MSG_Err_NoIcon 8 +#define MSG_Err_NoOpenURL 9 +#define MSG_Err_NoAppClass 10 +#define MSG_Err_NoWinClass 11 +#define MSG_Err_NoAppListClass 13 +#define MSG_Err_NoBrowserEditWinClass 14 +#define MSG_Err_NoMailerEditWinClass 15 +#define MSG_Err_NoFTPEditWinClass 16 +#define MSG_Err_PopupPortClass 17 +#define MSG_Err_PopphClass 18 +#define MSG_Err_NoApp 19 +#define MSG_Err_NoPrefs 20 +#define MSG_Err_BadPrefs 21 +#define MSG_Err_FailedSave 22 +#define MSG_App_Description 100 +#define MSG_App_Copyright 101 +#define MSG_App_ScreenTitle 102 +#define MSG_Menu_Project 200 +#define MSG_Menu_About 201 +#define MSG_Menu_AboutMUI 202 +#define MSG_Menu_Hide 203 +#define MSG_Menu_Quit 204 +#define MSG_Menu_Prefs 205 +#define MSG_Menu_Save 206 +#define MSG_Menu_Use 207 +#define MSG_Menu_LastSaved 208 +#define MSG_Menu_Restore 209 +#define MSG_Menu_Defaults 210 +#define MSG_Menu_MUI 212 +#define MSG_Win_WinTitle 300 +#define MSG_Win_Labels_Browsers 301 +#define MSG_Win_Labels_Mailers 302 +#define MSG_Win_Labels_FTPs 303 +#define MSG_Win_Labels_Misc 304 +#define MSG_Win_Save 305 +#define MSG_Win_Save_Help 306 +#define MSG_Win_Use 307 +#define MSG_Win_Use_Help 308 +#define MSG_Win_Apply 309 +#define MSG_Win_Apply_Help 310 +#define MSG_Win_Cancel 311 +#define MSG_Win_Cancel_Help 312 +#define MSG_AppList_Add 400 +#define MSG_AppList_Add_Help 401 +#define MSG_AppList_Edit 402 +#define MSG_AppList_Edit_Help 403 +#define MSG_AppList_Clone 404 +#define MSG_AppList_Clone_Help 405 +#define MSG_AppList_Delete 406 +#define MSG_AppList_Delete_Help 407 +#define MSG_AppList_Disable 408 +#define MSG_AppList_Disable_Help 409 +#define MSG_AppList_MoveUp_Help 410 +#define MSG_AppList_MoveDown_Help 411 +#define MSG_Edit_Use 500 +#define MSG_Edit_Use_Help 501 +#define MSG_Edit_Cancel 502 +#define MSG_Edit_Cancel_Help 503 +#define MSG_Edit_ListName 504 +#define MSG_Edit_ListPath 505 +#define MSG_Edit_Definitions 506 +#define MSG_Edit_ARexx 507 +#define MSG_Edit_PopURL 508 +#define MSG_Edit_PopScreen 509 +#define MSG_Edit_Name 510 +#define MSG_Edit_Name_Help 511 +#define MSG_Edit_Path 512 +#define MSG_Edit_Path_Help 513 +#define MSG_Edit_Port 514 +#define MSG_Edit_Port_Help 515 +#define MSG_Edit_Show 516 +#define MSG_Edit_Show_Help 517 +#define MSG_Edit_Screen 518 +#define MSG_Edit_Screen_Help 519 +#define MSG_Edit_OpenURL 520 +#define MSG_Edit_OpenURL_Help 521 +#define MSG_Edit_NewWin 522 +#define MSG_Edit_NewWin_Help 523 +#define MSG_Browser_List_Help 600 +#define MSG_Browser_WinTitle 601 +#define MSG_Browser_NewBrowser 602 +#define MSG_Mailer_List_Help 700 +#define MSG_Mailer_WinTitle 701 +#define MSG_Mailer_NewMailer 702 +#define MSG_Mailer_Write 703 +#define MSG_Mailer_Write_Help 704 +#define MSG_Mailer_PopAddress 705 +#define MSG_Mailer_Popsubject 706 +#define MSG_Mailer_PopBodyText 707 +#define MSG_Mailer_PopBodyFile 708 +#define MSG_FTP_List_Help 800 +#define MSG_FTP_WinTitle 801 +#define MSG_FTP_NewFTP 802 +#define MSG_FTP_RemoveURLQualifier 803 +#define MSG_FTP_RemoveURLQualifier_Help 804 +#define MSG_Misc_Options 900 +#define MSG_Misc_Defaults 901 +#define MSG_Misc_Prepend 902 +#define MSG_Misc_Prepend_Help 903 +#define MSG_Misc_UseMailer 904 +#define MSG_Misc_UseMailer_Help 905 +#define MSG_Misc_UseFTP 906 +#define MSG_Misc_UseFTP_Help 907 +#define MSG_Misc_Show 908 +#define MSG_Misc_Show_Help 909 +#define MSG_Misc_Bring 910 +#define MSG_Misc_Bring_Help 911 +#define MSG_Misc_Open 912 +#define MSG_Misc_Open_Help 913 +#define MSG_Misc_Launch 914 +#define MSG_Misc_Launch_Help 915 +#define MSG_About_WinTitle 1100 +#define MSG_About_OK 1111 +#define MSG_About_Descr 1112 + +#endif /* CATCOMP_NUMBERS */ + +/****************************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_ErrReqTitle_STR "OpenURL Error" +#define MSG_ErrReqGadget_STR "_Abort" +#define MSG_Err_NoMem_STR "Too few memory" +#define MSG_Err_NoMUI_STR "Can't open muimaster.library %ld.%ld or higher" +#define MSG_Err_NoIntuition_STR "Can't open intuition.library %ld.%ld or higher" +#define MSG_Err_NoUtility_STR "Can't open utility.library %ld.%ld or higher" +#define MSG_Err_NoGfx_STR "Can't open graphics.library %ld.%ld or higher" +#define MSG_Err_NoIcon_STR "Can't open icon.library %ld.%ld or higher" +#define MSG_Err_NoOpenURL_STR "Can't open openurl.library %ld.%ld or higher" +#define MSG_Err_NoAppClass_STR "Can't create AppClass" +#define MSG_Err_NoWinClass_STR "Can't create WinClass" +#define MSG_Err_NoAppListClass_STR "Can't create AppListClass" +#define MSG_Err_NoBrowserEditWinClass_STR "Can't create BrowserEditWinClass" +#define MSG_Err_NoMailerEditWinClass_STR "Can't create MailerEditWinClass" +#define MSG_Err_NoFTPEditWinClass_STR "Can't create FTPEditWinClass" +#define MSG_Err_PopupPortClass_STR "Can't create PopupPortClass" +#define MSG_Err_PopphClass_STR "Can't create PopphClass" +#define MSG_Err_NoApp_STR "Can't create application object" +#define MSG_Err_NoPrefs_STR "Can't obtain prefs from openurl.library" +#define MSG_Err_BadPrefs_STR "This version of this program doesn't know how\nto handle openurl.library prefs version %ld" +#define MSG_Err_FailedSave_STR "Can't save prefs" +#define MSG_App_Description_STR "OpenURL preferences application." +#define MSG_App_Copyright_STR "Public Domain Software" +#define MSG_App_ScreenTitle_STR "OpenURL" +#define MSG_Menu_Project_STR "Project" +#define MSG_Menu_About_STR "?\000About..." +#define MSG_Menu_AboutMUI_STR "!\000About MUI..." +#define MSG_Menu_Hide_STR "H\000Hide" +#define MSG_Menu_Quit_STR "Q\000Quit" +#define MSG_Menu_Prefs_STR "Preferences" +#define MSG_Menu_Save_STR "S\000Save" +#define MSG_Menu_Use_STR "U\000Use" +#define MSG_Menu_LastSaved_STR "L\000Last saved" +#define MSG_Menu_Restore_STR "R\000Restore" +#define MSG_Menu_Defaults_STR "D\000Default settings" +#define MSG_Menu_MUI_STR "M\000MUI Setting..." +#define MSG_Win_WinTitle_STR "OpenURL" +#define MSG_Win_Labels_Browsers_STR "Browsers" +#define MSG_Win_Labels_Mailers_STR "Mailers" +#define MSG_Win_Labels_FTPs_STR "FTPs" +#define MSG_Win_Labels_Misc_STR "Misc" +#define MSG_Win_Save_STR "_Save" +#define MSG_Win_Save_Help_STR "Save preferences." +#define MSG_Win_Use_STR "_Use" +#define MSG_Win_Use_Help_STR "Use preferences." +#define MSG_Win_Apply_STR "_Apply" +#define MSG_Win_Apply_Help_STR "Use preferences without closing window." +#define MSG_Win_Cancel_STR "_Cancel" +#define MSG_Win_Cancel_Help_STR "Close window, without using preferences." +#define MSG_AppList_Add_STR "A_dd" +#define MSG_AppList_Add_Help_STR "Add a new entry." +#define MSG_AppList_Edit_STR "_Edit" +#define MSG_AppList_Edit_Help_STR "Edit active entry." +#define MSG_AppList_Clone_STR "C_lone" +#define MSG_AppList_Clone_Help_STR "Clone active entry." +#define MSG_AppList_Delete_STR "Dele_te" +#define MSG_AppList_Delete_Help_STR "Delete active entry." +#define MSG_AppList_Disable_STR "D_isable" +#define MSG_AppList_Disable_Help_STR "Disable active entry." +#define MSG_AppList_MoveUp_Help_STR "Move active entry up." +#define MSG_AppList_MoveDown_Help_STR "Move active entry down." +#define MSG_Edit_Use_STR "_Use" +#define MSG_Edit_Use_Help_STR "Apply changes." +#define MSG_Edit_Cancel_STR "_Cancel" +#define MSG_Edit_Cancel_Help_STR "Close window." +#define MSG_Edit_ListName_STR "Name" +#define MSG_Edit_ListPath_STR "Path" +#define MSG_Edit_Definitions_STR "Definitions" +#define MSG_Edit_ARexx_STR "ARexx commands" +#define MSG_Edit_PopURL_STR "URL" +#define MSG_Edit_PopScreen_STR "Public screen name" +#define MSG_Edit_Name_STR "_Name" +#define MSG_Edit_Name_Help_STR "Name of entry." +#define MSG_Edit_Path_STR "_Path" +#define MSG_Edit_Path_Help_STR "Complete path to the application." +#define MSG_Edit_Port_STR "_ARexx port" +#define MSG_Edit_Port_Help_STR "Name of the application ARexx port\nto send commands to." +#define MSG_Edit_Show_STR "_Show" +#define MSG_Edit_Show_Help_STR "ARexx command to uniconify the application." +#define MSG_Edit_Screen_STR "_To front" +#define MSG_Edit_Screen_Help_STR "ARexx command to move the application\nscreen to front." +#define MSG_Edit_OpenURL_STR "_Open URL" +#define MSG_Edit_OpenURL_Help_STR "ARexx command to reach an URL." +#define MSG_Edit_NewWin_STR "N_ew window" +#define MSG_Edit_NewWin_Help_STR "ARexx command to reach an URL\nin a new window (or tab)." +#define MSG_Browser_List_Help_STR "List of browsers." +#define MSG_Browser_WinTitle_STR "Edit Browser" +#define MSG_Browser_NewBrowser_STR "New browser" +#define MSG_Mailer_List_Help_STR "List of Mailers." +#define MSG_Mailer_WinTitle_STR "Edit Mailer" +#define MSG_Mailer_NewMailer_STR "New mailer" +#define MSG_Mailer_Write_STR "_Write mail" +#define MSG_Mailer_Write_Help_STR "ARexx command to open a\n\"write a new EMail window\"." +#define MSG_Mailer_PopAddress_STR "Address" +#define MSG_Mailer_Popsubject_STR "Subject" +#define MSG_Mailer_PopBodyText_STR "Body text" +#define MSG_Mailer_PopBodyFile_STR "Body file" +#define MSG_FTP_List_Help_STR "List of FTP clients." +#define MSG_FTP_WinTitle_STR "Edit FTP client" +#define MSG_FTP_NewFTP_STR "New FTP client" +#define MSG_FTP_RemoveURLQualifier_STR "Re_move 'ftp://'" +#define MSG_FTP_RemoveURLQualifier_Help_STR "If selected, \"ftp://\" is removed\nfrom the URL." +#define MSG_Misc_Options_STR "Options" +#define MSG_Misc_Defaults_STR "Defaults" +#define MSG_Misc_Prepend_STR "_Prepend \"http://\" to URLs without a scheme" +#define MSG_Misc_Prepend_Help_STR "If selected, \"http://\" is added to any URL\nwithout a scheme, so that it is opened in the\nbrowser." +#define MSG_Misc_UseMailer_STR "S_end mailto: URLs to email application" +#define MSG_Misc_UseMailer_Help_STR "If selected, \"mailto:\" URLs are sent to\nthe mailer, otherwise they are sent to the\nbrowser." +#define MSG_Misc_UseFTP_STR "Se_nd \"ftp://\" URLs to FTP application" +#define MSG_Misc_UseFTP_Help_STR "If selected, \"fpt://\" URLs are sent to\nthe FTP client, otherwise they are sent to\nthe browser." +#define MSG_Misc_Show_STR "Un_iconify application" +#define MSG_Misc_Show_Help_STR "If selected, the application is uniconified,\nbefore sending the URL to it." +#define MSG_Misc_Bring_STR "_Bring browser screen to front" +#define MSG_Misc_Bring_Help_STR "If selected, the application screen is moved\nto front, before sending the URL." +#define MSG_Misc_Open_STR "_Open URL in new client window (or tab)" +#define MSG_Misc_Open_Help_STR "If selected, a new application window (or tab)\nis opened, before sending the URL." +#define MSG_Misc_Launch_STR "_Launch browser if one isn't running" +#define MSG_Misc_Launch_Help_STR "If selected, a new application is run, if none is found." +#define MSG_About_WinTitle_STR "About OpenURL" +#define MSG_About_OK_STR "_OK" +#define MSG_About_Descr_STR "\033bOpenURL\033n is a shared library for easily sending\nURLs from applications to browsers, mailers\nand FTP clients.\n\n\033cOpenURL is a Public Domain Software." + +#endif /* CATCOMP_STRINGS */ + +/****************************************************************************/ + +#ifdef CATCOMP_ARRAY + +struct CatCompArrayType +{ + ULONG cca_ID; + STRPTR cca_Str; +}; + +static const struct CatCompArrayType CatCompArray[] = +{ + {MSG_ErrReqTitle,(STRPTR)MSG_ErrReqTitle_STR}, + {MSG_ErrReqGadget,(STRPTR)MSG_ErrReqGadget_STR}, + {MSG_Err_NoMem,(STRPTR)MSG_Err_NoMem_STR}, + {MSG_Err_NoMUI,(STRPTR)MSG_Err_NoMUI_STR}, + {MSG_Err_NoIntuition,(STRPTR)MSG_Err_NoIntuition_STR}, + {MSG_Err_NoUtility,(STRPTR)MSG_Err_NoUtility_STR}, + {MSG_Err_NoGfx,(STRPTR)MSG_Err_NoGfx_STR}, + {MSG_Err_NoIcon,(STRPTR)MSG_Err_NoIcon_STR}, + {MSG_Err_NoOpenURL,(STRPTR)MSG_Err_NoOpenURL_STR}, + {MSG_Err_NoAppClass,(STRPTR)MSG_Err_NoAppClass_STR}, + {MSG_Err_NoWinClass,(STRPTR)MSG_Err_NoWinClass_STR}, + {MSG_Err_NoAppListClass,(STRPTR)MSG_Err_NoAppListClass_STR}, + {MSG_Err_NoBrowserEditWinClass,(STRPTR)MSG_Err_NoBrowserEditWinClass_STR}, + {MSG_Err_NoMailerEditWinClass,(STRPTR)MSG_Err_NoMailerEditWinClass_STR}, + {MSG_Err_NoFTPEditWinClass,(STRPTR)MSG_Err_NoFTPEditWinClass_STR}, + {MSG_Err_PopupPortClass,(STRPTR)MSG_Err_PopupPortClass_STR}, + {MSG_Err_PopphClass,(STRPTR)MSG_Err_PopphClass_STR}, + {MSG_Err_NoApp,(STRPTR)MSG_Err_NoApp_STR}, + {MSG_Err_NoPrefs,(STRPTR)MSG_Err_NoPrefs_STR}, + {MSG_Err_BadPrefs,(STRPTR)MSG_Err_BadPrefs_STR}, + {MSG_Err_FailedSave,(STRPTR)MSG_Err_FailedSave_STR}, + {MSG_App_Description,(STRPTR)MSG_App_Description_STR}, + {MSG_App_Copyright,(STRPTR)MSG_App_Copyright_STR}, + {MSG_App_ScreenTitle,(STRPTR)MSG_App_ScreenTitle_STR}, + {MSG_Menu_Project,(STRPTR)MSG_Menu_Project_STR}, + {MSG_Menu_About,(STRPTR)MSG_Menu_About_STR}, + {MSG_Menu_AboutMUI,(STRPTR)MSG_Menu_AboutMUI_STR}, + {MSG_Menu_Hide,(STRPTR)MSG_Menu_Hide_STR}, + {MSG_Menu_Quit,(STRPTR)MSG_Menu_Quit_STR}, + {MSG_Menu_Prefs,(STRPTR)MSG_Menu_Prefs_STR}, + {MSG_Menu_Save,(STRPTR)MSG_Menu_Save_STR}, + {MSG_Menu_Use,(STRPTR)MSG_Menu_Use_STR}, + {MSG_Menu_LastSaved,(STRPTR)MSG_Menu_LastSaved_STR}, + {MSG_Menu_Restore,(STRPTR)MSG_Menu_Restore_STR}, + {MSG_Menu_Defaults,(STRPTR)MSG_Menu_Defaults_STR}, + {MSG_Menu_MUI,(STRPTR)MSG_Menu_MUI_STR}, + {MSG_Win_WinTitle,(STRPTR)MSG_Win_WinTitle_STR}, + {MSG_Win_Labels_Browsers,(STRPTR)MSG_Win_Labels_Browsers_STR}, + {MSG_Win_Labels_Mailers,(STRPTR)MSG_Win_Labels_Mailers_STR}, + {MSG_Win_Labels_FTPs,(STRPTR)MSG_Win_Labels_FTPs_STR}, + {MSG_Win_Labels_Misc,(STRPTR)MSG_Win_Labels_Misc_STR}, + {MSG_Win_Save,(STRPTR)MSG_Win_Save_STR}, + {MSG_Win_Save_Help,(STRPTR)MSG_Win_Save_Help_STR}, + {MSG_Win_Use,(STRPTR)MSG_Win_Use_STR}, + {MSG_Win_Use_Help,(STRPTR)MSG_Win_Use_Help_STR}, + {MSG_Win_Apply,(STRPTR)MSG_Win_Apply_STR}, + {MSG_Win_Apply_Help,(STRPTR)MSG_Win_Apply_Help_STR}, + {MSG_Win_Cancel,(STRPTR)MSG_Win_Cancel_STR}, + {MSG_Win_Cancel_Help,(STRPTR)MSG_Win_Cancel_Help_STR}, + {MSG_AppList_Add,(STRPTR)MSG_AppList_Add_STR}, + {MSG_AppList_Add_Help,(STRPTR)MSG_AppList_Add_Help_STR}, + {MSG_AppList_Edit,(STRPTR)MSG_AppList_Edit_STR}, + {MSG_AppList_Edit_Help,(STRPTR)MSG_AppList_Edit_Help_STR}, + {MSG_AppList_Clone,(STRPTR)MSG_AppList_Clone_STR}, + {MSG_AppList_Clone_Help,(STRPTR)MSG_AppList_Clone_Help_STR}, + {MSG_AppList_Delete,(STRPTR)MSG_AppList_Delete_STR}, + {MSG_AppList_Delete_Help,(STRPTR)MSG_AppList_Delete_Help_STR}, + {MSG_AppList_Disable,(STRPTR)MSG_AppList_Disable_STR}, + {MSG_AppList_Disable_Help,(STRPTR)MSG_AppList_Disable_Help_STR}, + {MSG_AppList_MoveUp_Help,(STRPTR)MSG_AppList_MoveUp_Help_STR}, + {MSG_AppList_MoveDown_Help,(STRPTR)MSG_AppList_MoveDown_Help_STR}, + {MSG_Edit_Use,(STRPTR)MSG_Edit_Use_STR}, + {MSG_Edit_Use_Help,(STRPTR)MSG_Edit_Use_Help_STR}, + {MSG_Edit_Cancel,(STRPTR)MSG_Edit_Cancel_STR}, + {MSG_Edit_Cancel_Help,(STRPTR)MSG_Edit_Cancel_Help_STR}, + {MSG_Edit_ListName,(STRPTR)MSG_Edit_ListName_STR}, + {MSG_Edit_ListPath,(STRPTR)MSG_Edit_ListPath_STR}, + {MSG_Edit_Definitions,(STRPTR)MSG_Edit_Definitions_STR}, + {MSG_Edit_ARexx,(STRPTR)MSG_Edit_ARexx_STR}, + {MSG_Edit_PopURL,(STRPTR)MSG_Edit_PopURL_STR}, + {MSG_Edit_PopScreen,(STRPTR)MSG_Edit_PopScreen_STR}, + {MSG_Edit_Name,(STRPTR)MSG_Edit_Name_STR}, + {MSG_Edit_Name_Help,(STRPTR)MSG_Edit_Name_Help_STR}, + {MSG_Edit_Path,(STRPTR)MSG_Edit_Path_STR}, + {MSG_Edit_Path_Help,(STRPTR)MSG_Edit_Path_Help_STR}, + {MSG_Edit_Port,(STRPTR)MSG_Edit_Port_STR}, + {MSG_Edit_Port_Help,(STRPTR)MSG_Edit_Port_Help_STR}, + {MSG_Edit_Show,(STRPTR)MSG_Edit_Show_STR}, + {MSG_Edit_Show_Help,(STRPTR)MSG_Edit_Show_Help_STR}, + {MSG_Edit_Screen,(STRPTR)MSG_Edit_Screen_STR}, + {MSG_Edit_Screen_Help,(STRPTR)MSG_Edit_Screen_Help_STR}, + {MSG_Edit_OpenURL,(STRPTR)MSG_Edit_OpenURL_STR}, + {MSG_Edit_OpenURL_Help,(STRPTR)MSG_Edit_OpenURL_Help_STR}, + {MSG_Edit_NewWin,(STRPTR)MSG_Edit_NewWin_STR}, + {MSG_Edit_NewWin_Help,(STRPTR)MSG_Edit_NewWin_Help_STR}, + {MSG_Browser_List_Help,(STRPTR)MSG_Browser_List_Help_STR}, + {MSG_Browser_WinTitle,(STRPTR)MSG_Browser_WinTitle_STR}, + {MSG_Browser_NewBrowser,(STRPTR)MSG_Browser_NewBrowser_STR}, + {MSG_Mailer_List_Help,(STRPTR)MSG_Mailer_List_Help_STR}, + {MSG_Mailer_WinTitle,(STRPTR)MSG_Mailer_WinTitle_STR}, + {MSG_Mailer_NewMailer,(STRPTR)MSG_Mailer_NewMailer_STR}, + {MSG_Mailer_Write,(STRPTR)MSG_Mailer_Write_STR}, + {MSG_Mailer_Write_Help,(STRPTR)MSG_Mailer_Write_Help_STR}, + {MSG_Mailer_PopAddress,(STRPTR)MSG_Mailer_PopAddress_STR}, + {MSG_Mailer_Popsubject,(STRPTR)MSG_Mailer_Popsubject_STR}, + {MSG_Mailer_PopBodyText,(STRPTR)MSG_Mailer_PopBodyText_STR}, + {MSG_Mailer_PopBodyFile,(STRPTR)MSG_Mailer_PopBodyFile_STR}, + {MSG_FTP_List_Help,(STRPTR)MSG_FTP_List_Help_STR}, + {MSG_FTP_WinTitle,(STRPTR)MSG_FTP_WinTitle_STR}, + {MSG_FTP_NewFTP,(STRPTR)MSG_FTP_NewFTP_STR}, + {MSG_FTP_RemoveURLQualifier,(STRPTR)MSG_FTP_RemoveURLQualifier_STR}, + {MSG_FTP_RemoveURLQualifier_Help,(STRPTR)MSG_FTP_RemoveURLQualifier_Help_STR}, + {MSG_Misc_Options,(STRPTR)MSG_Misc_Options_STR}, + {MSG_Misc_Defaults,(STRPTR)MSG_Misc_Defaults_STR}, + {MSG_Misc_Prepend,(STRPTR)MSG_Misc_Prepend_STR}, + {MSG_Misc_Prepend_Help,(STRPTR)MSG_Misc_Prepend_Help_STR}, + {MSG_Misc_UseMailer,(STRPTR)MSG_Misc_UseMailer_STR}, + {MSG_Misc_UseMailer_Help,(STRPTR)MSG_Misc_UseMailer_Help_STR}, + {MSG_Misc_UseFTP,(STRPTR)MSG_Misc_UseFTP_STR}, + {MSG_Misc_UseFTP_Help,(STRPTR)MSG_Misc_UseFTP_Help_STR}, + {MSG_Misc_Show,(STRPTR)MSG_Misc_Show_STR}, + {MSG_Misc_Show_Help,(STRPTR)MSG_Misc_Show_Help_STR}, + {MSG_Misc_Bring,(STRPTR)MSG_Misc_Bring_STR}, + {MSG_Misc_Bring_Help,(STRPTR)MSG_Misc_Bring_Help_STR}, + {MSG_Misc_Open,(STRPTR)MSG_Misc_Open_STR}, + {MSG_Misc_Open_Help,(STRPTR)MSG_Misc_Open_Help_STR}, + {MSG_Misc_Launch,(STRPTR)MSG_Misc_Launch_STR}, + {MSG_Misc_Launch_Help,(STRPTR)MSG_Misc_Launch_Help_STR}, + {MSG_About_WinTitle,(STRPTR)MSG_About_WinTitle_STR}, + {MSG_About_OK,(STRPTR)MSG_About_OK_STR}, + {MSG_About_Descr,(STRPTR)MSG_About_Descr_STR}, +}; + +#endif /* CATCOMP_ARRAY */ + +/****************************************************************************/ + +#endif /* _LOC_H */ diff --git a/rom/hidds/pci/pcitool/strings.h b/rom/hidds/pci/pcitool/strings.h new file mode 100644 index 00000000000..430e39c9d74 --- /dev/null +++ b/rom/hidds/pci/pcitool/strings.h @@ -0,0 +1,220 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/rom/hidds/pci/pcitool/catalogs/pcitool.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef PCITOOL_STRINGS_H +#define PCITOOL_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_TITLE 0 +#define MSG_WINTITLE 1 +#define MSG_DESCRIPTION 2 +#define MSG_ERROR_LOCALE 3 +#define MSG_ERROR_OK 4 +#define MSG_ERROR_HEADER 5 +#define MSG_DRIVER_INFO 6 +#define MSG_DRIVER_NAME 7 +#define MSG_DIRECT_BUS 8 +#define MSG_HARDWARE_INFO 9 +#define MSG_PCI_DEVICE_INFO 10 +#define MSG_DEVICE_DESCRIPTION 11 +#define MSG_VENDORNAME 12 +#define MSG_PRODUCTNAME 13 +#define MSG_SUBSYSTEM 14 +#define MSG_VENDORID 15 +#define MSG_PRODUCTID 16 +#define MSG_REVISIONID 17 +#define MSG_INTERFACE 18 +#define MSG_CLASS 19 +#define MSG_SUBCLASS 20 +#define MSG_IRQ 21 +#define MSG_ROM_BASE 22 +#define MSG_ROM_SIZE 23 +#define MSG_BRIDGE 24 +#define MSG_MEMORY_RANGE 25 +#define MSG_PREFETCHABLE_MEMORY 26 +#define MSG_IO_RANGE 27 +#define MSG_IO_MSG 28 +#define MSG_IO 29 +#define MSG_MEMORY 30 +#define MSG_PREFETCHABLE 31 +#define MSG_YES 32 +#define MSG_NO 33 +#define MSG_NA 34 +#define MSG_NOT 35 +#define MSG_SIZE4 36 +#define MSG_SIZE8 37 +#define MSG_SAVETORAMDISK 38 +#define MSG_SAVEALLTORAMDISK 39 +#define MSG_UNUSED 40 +#define MSG_IO_BASE 41 +#define MSG_OWNER 42 +#define MSG_PCIE_DEVICE_INFO 43 +#define MSG_PCIE_SERIAL_NUMBER 44 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_TITLE_STR "PCI Tool" +#define MSG_WINTITLE_STR "PCI Tool" +#define MSG_DESCRIPTION_STR "PCI querying and managment" +#define MSG_ERROR_LOCALE_STR "Can't open locale" +#define MSG_ERROR_OK_STR "Ok" +#define MSG_ERROR_HEADER_STR "ERROR" +#define MSG_DRIVER_INFO_STR "Driver info" +#define MSG_DRIVER_NAME_STR "Driver name:" +#define MSG_DIRECT_BUS_STR "Direct bus:" +#define MSG_HARDWARE_INFO_STR "Hardware info:" +#define MSG_PCI_DEVICE_INFO_STR "PCI device info" +#define MSG_DEVICE_DESCRIPTION_STR "Description:" +#define MSG_VENDORNAME_STR "Vendor Name:" +#define MSG_PRODUCTNAME_STR "Product Name:" +#define MSG_SUBSYSTEM_STR "Subsystem:" +#define MSG_VENDORID_STR "VendorID:" +#define MSG_PRODUCTID_STR "ProductID:" +#define MSG_REVISIONID_STR "RevisionID:" +#define MSG_INTERFACE_STR "Interface:" +#define MSG_CLASS_STR "Class:" +#define MSG_SUBCLASS_STR "Subclass:" +#define MSG_IRQ_STR "IRQ:" +#define MSG_ROM_BASE_STR "ROM Base:" +#define MSG_ROM_SIZE_STR "ROM Size:" +#define MSG_BRIDGE_STR "Bridge handles bus %d (ISA %senabled, VGA %senabled)" +#define MSG_MEMORY_RANGE_STR "Memory ranges from %08x to %08x" +#define MSG_PREFETCHABLE_MEMORY_STR "Prefetchable ranges memory from %08x to %08x" +#define MSG_IO_RANGE_STR "IO ranges from %04x to %04x" +#define MSG_IO_MSG_STR "IO: %s, MEM: %s, Master: %s, PaletteSnoop: %s, 66MHz capable: %s" +#define MSG_IO_STR "I/O" +#define MSG_MEMORY_STR "Memory" +#define MSG_PREFETCHABLE_STR "Prefetchable Memory" +#define MSG_YES_STR "yes" +#define MSG_NO_STR "no" +#define MSG_NA_STR "N/A" +#define MSG_NOT_STR "not" +#define MSG_SIZE4_STR "%s at 0x%04x (size 0x%04x)" +#define MSG_SIZE8_STR "%s at 0x%08x (size 0x%08x)" +#define MSG_SAVETORAMDISK_STR "Save Device Information to RAM Disk" +#define MSG_SAVEALLTORAMDISK_STR "Save complete PCI Information to RAM Disk" +#define MSG_UNUSED_STR "--unused--" +#define MSG_IO_BASE_STR "I/O base:" +#define MSG_OWNER_STR "Used by:" +#define MSG_PCIE_DEVICE_INFO_STR "PCIe device info" +#define MSG_PCIE_SERIAL_NUMBER_STR "PCIe Serial Number" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_TITLE,(STRPTR)MSG_TITLE_STR}, + {MSG_WINTITLE,(STRPTR)MSG_WINTITLE_STR}, + {MSG_DESCRIPTION,(STRPTR)MSG_DESCRIPTION_STR}, + {MSG_ERROR_LOCALE,(STRPTR)MSG_ERROR_LOCALE_STR}, + {MSG_ERROR_OK,(STRPTR)MSG_ERROR_OK_STR}, + {MSG_ERROR_HEADER,(STRPTR)MSG_ERROR_HEADER_STR}, + {MSG_DRIVER_INFO,(STRPTR)MSG_DRIVER_INFO_STR}, + {MSG_DRIVER_NAME,(STRPTR)MSG_DRIVER_NAME_STR}, + {MSG_DIRECT_BUS,(STRPTR)MSG_DIRECT_BUS_STR}, + {MSG_HARDWARE_INFO,(STRPTR)MSG_HARDWARE_INFO_STR}, + {MSG_PCI_DEVICE_INFO,(STRPTR)MSG_PCI_DEVICE_INFO_STR}, + {MSG_DEVICE_DESCRIPTION,(STRPTR)MSG_DEVICE_DESCRIPTION_STR}, + {MSG_VENDORNAME,(STRPTR)MSG_VENDORNAME_STR}, + {MSG_PRODUCTNAME,(STRPTR)MSG_PRODUCTNAME_STR}, + {MSG_SUBSYSTEM,(STRPTR)MSG_SUBSYSTEM_STR}, + {MSG_VENDORID,(STRPTR)MSG_VENDORID_STR}, + {MSG_PRODUCTID,(STRPTR)MSG_PRODUCTID_STR}, + {MSG_REVISIONID,(STRPTR)MSG_REVISIONID_STR}, + {MSG_INTERFACE,(STRPTR)MSG_INTERFACE_STR}, + {MSG_CLASS,(STRPTR)MSG_CLASS_STR}, + {MSG_SUBCLASS,(STRPTR)MSG_SUBCLASS_STR}, + {MSG_IRQ,(STRPTR)MSG_IRQ_STR}, + {MSG_ROM_BASE,(STRPTR)MSG_ROM_BASE_STR}, + {MSG_ROM_SIZE,(STRPTR)MSG_ROM_SIZE_STR}, + {MSG_BRIDGE,(STRPTR)MSG_BRIDGE_STR}, + {MSG_MEMORY_RANGE,(STRPTR)MSG_MEMORY_RANGE_STR}, + {MSG_PREFETCHABLE_MEMORY,(STRPTR)MSG_PREFETCHABLE_MEMORY_STR}, + {MSG_IO_RANGE,(STRPTR)MSG_IO_RANGE_STR}, + {MSG_IO_MSG,(STRPTR)MSG_IO_MSG_STR}, + {MSG_IO,(STRPTR)MSG_IO_STR}, + {MSG_MEMORY,(STRPTR)MSG_MEMORY_STR}, + {MSG_PREFETCHABLE,(STRPTR)MSG_PREFETCHABLE_STR}, + {MSG_YES,(STRPTR)MSG_YES_STR}, + {MSG_NO,(STRPTR)MSG_NO_STR}, + {MSG_NA,(STRPTR)MSG_NA_STR}, + {MSG_NOT,(STRPTR)MSG_NOT_STR}, + {MSG_SIZE4,(STRPTR)MSG_SIZE4_STR}, + {MSG_SIZE8,(STRPTR)MSG_SIZE8_STR}, + {MSG_SAVETORAMDISK,(STRPTR)MSG_SAVETORAMDISK_STR}, + {MSG_SAVEALLTORAMDISK,(STRPTR)MSG_SAVEALLTORAMDISK_STR}, + {MSG_UNUSED,(STRPTR)MSG_UNUSED_STR}, + {MSG_IO_BASE,(STRPTR)MSG_IO_BASE_STR}, + {MSG_OWNER,(STRPTR)MSG_OWNER_STR}, + {MSG_PCIE_DEVICE_INFO,(STRPTR)MSG_PCIE_DEVICE_INFO_STR}, + {MSG_PCIE_SERIAL_NUMBER,(STRPTR)MSG_PCIE_SERIAL_NUMBER_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* PCITOOL_STRINGS_H */ diff --git a/workbench/c/R/strings.h b/workbench/c/R/strings.h new file mode 100644 index 00000000000..2700d5a1fad --- /dev/null +++ b/workbench/c/R/strings.h @@ -0,0 +1,130 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/c/R/catalogs/R.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef R_STRINGS_H +#define R_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_APP_TITLE 0 +#define MSG_APP_DESCRIPTION 1 +#define MSG_WIN_TITLE 2 +#define MSG_OK 3 +#define MSG_CANCEL 4 +#define MSG_ERROR_ALLOCATE 5 +#define MSG_ERROR_RETURN 6 +#define MSG_ERROR_POOL 7 +#define MSG_ERROR_STRUCT 8 +#define MSG_ERROR_ARGS 9 +#define MSG_ERROR_NOTFOUND 10 +#define MSG_ERROR_TMPLT_GET 11 +#define MSG_ERROR_TMPLT_PARSE 12 +#define MSG_ERROR_GUI 13 +#define MSG_ERROR_DEFAULTS 14 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_APP_TITLE_STR "R" +#define MSG_APP_DESCRIPTION_STR "GUI Generator" +#define MSG_WIN_TITLE_STR "R : %s" +#define MSG_OK_STR "OK" +#define MSG_CANCEL_STR "Cancel" +#define MSG_ERROR_ALLOCATE_STR "Can't allocate struct Req\n" +#define MSG_ERROR_RETURN_STR "\"%s\" failed, return code %ld\n" +#define MSG_ERROR_POOL_STR "Can't create poolmem\n" +#define MSG_ERROR_STRUCT_STR "Can't allocate struct Req\n" +#define MSG_ERROR_ARGS_STR "Failed to parse arguments\n" +#define MSG_ERROR_NOTFOUND_STR "Command not found\n" +#define MSG_ERROR_TMPLT_GET_STR "Failed to get template\n" +#define MSG_ERROR_TMPLT_PARSE_STR "Failed to parse the template\n" +#define MSG_ERROR_GUI_STR "Failed to create application object\n" +#define MSG_ERROR_DEFAULTS_STR "Failed to set the default values\n" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_APP_TITLE,(STRPTR)MSG_APP_TITLE_STR}, + {MSG_APP_DESCRIPTION,(STRPTR)MSG_APP_DESCRIPTION_STR}, + {MSG_WIN_TITLE,(STRPTR)MSG_WIN_TITLE_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_CANCEL,(STRPTR)MSG_CANCEL_STR}, + {MSG_ERROR_ALLOCATE,(STRPTR)MSG_ERROR_ALLOCATE_STR}, + {MSG_ERROR_RETURN,(STRPTR)MSG_ERROR_RETURN_STR}, + {MSG_ERROR_POOL,(STRPTR)MSG_ERROR_POOL_STR}, + {MSG_ERROR_STRUCT,(STRPTR)MSG_ERROR_STRUCT_STR}, + {MSG_ERROR_ARGS,(STRPTR)MSG_ERROR_ARGS_STR}, + {MSG_ERROR_NOTFOUND,(STRPTR)MSG_ERROR_NOTFOUND_STR}, + {MSG_ERROR_TMPLT_GET,(STRPTR)MSG_ERROR_TMPLT_GET_STR}, + {MSG_ERROR_TMPLT_PARSE,(STRPTR)MSG_ERROR_TMPLT_PARSE_STR}, + {MSG_ERROR_GUI,(STRPTR)MSG_ERROR_GUI_STR}, + {MSG_ERROR_DEFAULTS,(STRPTR)MSG_ERROR_DEFAULTS_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* R_STRINGS_H */ diff --git a/workbench/classes/zune/nlist/nlisttree_mcp/locale.c b/workbench/classes/zune/nlist/nlisttree_mcp/locale.c new file mode 100644 index 00000000000..78f1d5fc51e --- /dev/null +++ b/workbench/classes/zune/nlist/nlisttree_mcp/locale.c @@ -0,0 +1,156 @@ +/*************************************************************************** + + NListtree.mcc - New Listtree MUI Custom Class + Copyright (C) 1999-2001 by Carsten Scholling + Copyright (C) 2001-2014 NList Open Source Team + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + NList classes Support Site: http://www.sf.net/projects/nlist-classes + + $Id: C_c.sd 716 2014-01-26 09:32:35Z damato $ + +***************************************************************************/ + + /* + * If this file is named 'locale.c' it is automatically + * generated by 'FlexCat' from C_c.sd. PLEASE DO NOT EDIT!!! + */ + +#include + +#include +#include "Debug.h" + +struct FC_Type { const long ID; const char * const Str; }; + +const struct FC_Type _MSG_TAB_LAYOUT = { 1, "Layout" }; +const struct FC_Type _MSG_GROUP_IMAGES_COLORS = { 2, "Images/Colors" }; +const struct FC_Type _MSG_BUTTON_LABEL_CLOSED = { 3, "Closed" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_CLOSED = { 4, "c" }; +const struct FC_Type _MSG_HELP_CLOSED_IMAGE = { 5, "Image to use for closed nodes." }; +const struct FC_Type _MSG_WIN_TITLE_CLOSED_IMAGE = { 6, "Adjust image for closed nodes" }; +const struct FC_Type _MSG_BUTTON_LABEL_LINES = { 7, "Lines" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_LINES = { 8, "l" }; +const struct FC_Type _MSG_HELP_LINES_COLOR = { 9, "Color to use for lines." }; +const struct FC_Type _MSG_WIN_TITLE_LINES_COLOR = { 10, "Adjust lines color" }; +const struct FC_Type _MSG_BUTTON_LABEL_OPEN = { 11, "Open" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_OPEN = { 12, "o" }; +const struct FC_Type _MSG_HELP_OPEN_IMAGE = { 13, "Image to use for open nodes." }; +const struct FC_Type _MSG_WIN_TITLE_OPEN_IMAGE = { 14, "Adjust image for open nodes" }; +const struct FC_Type _MSG_BUTTON_LABEL_SHADOW = { 15, "Shadow" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_SHADOW = { 16, "w" }; +const struct FC_Type _MSG_HELP_SHADOW_COLOR = { 17, "Color to use to cast\nshadows after lines." }; +const struct FC_Type _MSG_WIN_TITLE_SHADOW_COLOR = { 18, "Adjust shadow color" }; +const struct FC_Type _MSG_BUTTON_LABEL_SPECIAL = { 19, "Special" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_SPECIAL = { 20, "i" }; +const struct FC_Type _MSG_HELP_SPECIAL_IMAGE = { 21, "A special image to be\ndisplayed after every node." }; +const struct FC_Type _MSG_WIN_TITLE_SPECIAL_IMAGE = { 22, "Adjust special image" }; +const struct FC_Type _MSG_BUTTON_LABEL_DRAW = { 23, "Draw" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_DRAW = { 24, "d" }; +const struct FC_Type _MSG_HELP_DRAW_COLOR = { 25, "A draw color to be combined\nwith the lines color." }; +const struct FC_Type _MSG_WIN_TITLE_DRAW_COLOR = { 26, "Adjust draw color" }; +const struct FC_Type _MSG_GROUP_STYLE = { 27, "Style" }; +const struct FC_Type _MSG_CYCLE_LABEL_STYLE = { 28, "Style" }; +const struct FC_Type _MSG_CYCLE_SHORTCUT_STYLE = { 29, "s" }; +const struct FC_Type _MSG_HELP_STYLE = { 30, "Select here the global style of the tree.\n\nDepending on your choice, some of the\noptions above may become (un)available." }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_NORMAL = { 31, "Normal" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_INSERTED = { 32, "Inserted" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_LINES = { 33, "Lines" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_WIN98 = { 34, "Win98" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_MAC = { 35, "Mac" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_LINES3D = { 36, "Lines 3D" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_WIN98PLUS = { 37, "Win98+" }; +const struct FC_Type _MSG_CYCLE_ITEM_STYLE_GLOW = { 38, "Glow" }; +const struct FC_Type _MSG_BUTTON_LABEL_SPACE = { 39, "Spacing" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_SPACE = { 40, "p" }; +const struct FC_Type _MSG_HELP_SPACE = { 41, "The more spacing, the wider\nthe listtree will be." }; +const struct FC_Type _MSG_BUTTON_LABEL_REMEMBER = { 42, "Remember status?" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_REMEMBER = { 43, "r" }; +const struct FC_Type _MSG_HELP_REMEMBER = { 44, "If enabled, the open/closed status of nodes\nwill be 'remembered' after the listtree is closed\nthe next time it is opened again.\n\nPlease note, however, that an application\ncan override your choice here." }; +const struct FC_Type _MSG_BUTTON_LABEL_AUTOSCROLL = { 45, "Autoscroll?" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_AUTOSCROLL = { 46, "a" }; +const struct FC_Type _MSG_HELP_AUTOSCROLL = { 47, "If enabled, the listview will auto-scroll its\ncontents when opening nodes to try and fit the\nvisible area." }; +const struct FC_Type _MSG_TAB_EXAMPLE = { 48, "Example" }; +const struct FC_Type _MSG_HELP_LISTVIEW_EXAMPLE = { 49, "This NListtree object reacts in real time to\nthe changes you apply under the 'Layout' tab.\n\nGive it a try! :)" }; +const struct FC_Type _MSG_BUTTON_LABEL_EXPAND = { 50, "Expand" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_EXPAND = { 51, "n" }; +const struct FC_Type _MSG_BUTTON_LABEL_COLLAPSE = { 52, "Collapse" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_COLLAPSE = { 53, "e" }; +const struct FC_Type _MSG_BUTTON_LABEL_LINETYPES = { 54, "Line type" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_LINETYPES = { 55, "l" }; +const struct FC_Type _MSG_LINETYPE_DISABLED = { 56, "Disabled" }; +const struct FC_Type _MSG_LINETYPE_NORMAL = { 57, "Normal" }; +const struct FC_Type _MSG_LINETYPE_DOTTED = { 58, "Dotted" }; +const struct FC_Type _MSG_LINETYPE_SHADOW = { 59, "Shadow" }; +const struct FC_Type _MSG_LINETYPE_GLOW = { 60, "Glow" }; +const struct FC_Type _MSG_HELP_LINETYPES = { 61, "Select the line type used for drawing\nthe individual levels in the listtree." }; +const struct FC_Type _MSG_BUTTON_LABEL_FOLDER = { 62, "Folder image" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_FOLDER = { 63, "f" }; +const struct FC_Type _MSG_WIN_TITLE_FOLDER_IMAGE = { 64, "Adjust folder image" }; +const struct FC_Type _MSG_HELP_FOLDER_IMAGE = { 65, "An image displayed in front of every\nnode containing subnodes." }; +const struct FC_Type _MSG_BUTTON_LABEL_FOLDERIMAGE = { 66, "Use folder image" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_FOLDERIMAGE = { 67, "i" }; +const struct FC_Type _MSG_HELP_FOLDERIMAGE = { 68, "Select if you want a folder image to\nappear in front of every node containing\nsubnodes." }; +const struct FC_Type _MSG_BUTTON_LABEL_INDENTWIDTH = { 69, "Additional indent width" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_INDENTWIDTH = { 70, "w" }; +const struct FC_Type _MSG_HELP_INDENTWIDTH = { 71, "Specify an additional indent\nwidth applied to each subnode." }; +const struct FC_Type _MSG_BUTTON_LABEL_GLOW = { 72, "Glow color" }; +const struct FC_Type _MSG_BUTTON_SHORTCUT_GLOW = { 73, "g" }; +const struct FC_Type _MSG_WIN_TITLE_GLOW_COLOR = { 74, "Set glow line color" }; +const struct FC_Type _MSG_HELP_GLOW_COLOR = { 75, "Allows to set the color for the glow\nline type" }; + +static struct Catalog *NL_Catalog = NULL; + +/*** Catalog functions ***/ +/// tr() +const char *tr(const void *fcstr) +{ + const char *defaultstr = ((struct FC_Type *)fcstr)->Str; + + if(LocaleBase) + return (const char *)GetCatalogStr(NL_Catalog, ((struct FC_Type *)fcstr)->ID, (STRPTR)defaultstr); + + return defaultstr; +} +/// +/// CloseCat() +void CloseCat(void) +{ + ENTER(); + + if(NL_Catalog) + { + CloseCatalog(NL_Catalog); + NL_Catalog = NULL; + } + + LEAVE(); +} +/// +/// OpenCat(void) +BOOL OpenCat(void) +{ + static const struct TagItem tags[] = { + { OC_BuiltInLanguage, (IPTR)"english" }, + { OC_Version, 2 }, + { TAG_DONE, 0 } + }; + + ENTER(); + + if(LocaleBase && NL_Catalog == NULL) + NL_Catalog = OpenCatalogA(NULL, (STRPTR)"NListtree_mcp.catalog", (struct TagItem *)&tags[0]); + + RETURN((BOOL)(NL_Catalog != NULL)); + return (BOOL)(NL_Catalog != NULL); +} +/// diff --git a/workbench/classes/zune/nlist/nlisttree_mcp/locale.h b/workbench/classes/zune/nlist/nlisttree_mcp/locale.h new file mode 100644 index 00000000000..e9b4b0da655 --- /dev/null +++ b/workbench/classes/zune/nlist/nlisttree_mcp/locale.h @@ -0,0 +1,191 @@ +/*************************************************************************** + + NListtree.mcc - New Listtree MUI Custom Class + Copyright (C) 1999-2001 by Carsten Scholling + Copyright (C) 2001-2014 NList Open Source Team + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + NList classes Support Site: http://www.sf.net/projects/nlist-classes + + $Id: C_h.sd 716 2014-01-26 09:32:35Z damato $ + +***************************************************************************/ + + /* + * If this file is named 'locale.h' it is automatically + * generated by 'FlexCat' from C_h.sd. PLEASE DO NOT EDIT!!! + */ + +#ifndef NListtree_mcp_LOCALE_H +#define NListtree_mcp_LOCALE_H + +// catalog translation functions +extern const char *tr(const void *); +extern BOOL OpenCat(void); +extern void CloseCat(void); + +// const pointers to internal strings +extern const void* const _MSG_TAB_LAYOUT; +extern const void* const _MSG_GROUP_IMAGES_COLORS; +extern const void* const _MSG_BUTTON_LABEL_CLOSED; +extern const void* const _MSG_BUTTON_SHORTCUT_CLOSED; +extern const void* const _MSG_HELP_CLOSED_IMAGE; +extern const void* const _MSG_WIN_TITLE_CLOSED_IMAGE; +extern const void* const _MSG_BUTTON_LABEL_LINES; +extern const void* const _MSG_BUTTON_SHORTCUT_LINES; +extern const void* const _MSG_HELP_LINES_COLOR; +extern const void* const _MSG_WIN_TITLE_LINES_COLOR; +extern const void* const _MSG_BUTTON_LABEL_OPEN; +extern const void* const _MSG_BUTTON_SHORTCUT_OPEN; +extern const void* const _MSG_HELP_OPEN_IMAGE; +extern const void* const _MSG_WIN_TITLE_OPEN_IMAGE; +extern const void* const _MSG_BUTTON_LABEL_SHADOW; +extern const void* const _MSG_BUTTON_SHORTCUT_SHADOW; +extern const void* const _MSG_HELP_SHADOW_COLOR; +extern const void* const _MSG_WIN_TITLE_SHADOW_COLOR; +extern const void* const _MSG_BUTTON_LABEL_SPECIAL; +extern const void* const _MSG_BUTTON_SHORTCUT_SPECIAL; +extern const void* const _MSG_HELP_SPECIAL_IMAGE; +extern const void* const _MSG_WIN_TITLE_SPECIAL_IMAGE; +extern const void* const _MSG_BUTTON_LABEL_DRAW; +extern const void* const _MSG_BUTTON_SHORTCUT_DRAW; +extern const void* const _MSG_HELP_DRAW_COLOR; +extern const void* const _MSG_WIN_TITLE_DRAW_COLOR; +extern const void* const _MSG_GROUP_STYLE; +extern const void* const _MSG_CYCLE_LABEL_STYLE; +extern const void* const _MSG_CYCLE_SHORTCUT_STYLE; +extern const void* const _MSG_HELP_STYLE; +extern const void* const _MSG_CYCLE_ITEM_STYLE_NORMAL; +extern const void* const _MSG_CYCLE_ITEM_STYLE_INSERTED; +extern const void* const _MSG_CYCLE_ITEM_STYLE_LINES; +extern const void* const _MSG_CYCLE_ITEM_STYLE_WIN98; +extern const void* const _MSG_CYCLE_ITEM_STYLE_MAC; +extern const void* const _MSG_CYCLE_ITEM_STYLE_LINES3D; +extern const void* const _MSG_CYCLE_ITEM_STYLE_WIN98PLUS; +extern const void* const _MSG_CYCLE_ITEM_STYLE_GLOW; +extern const void* const _MSG_BUTTON_LABEL_SPACE; +extern const void* const _MSG_BUTTON_SHORTCUT_SPACE; +extern const void* const _MSG_HELP_SPACE; +extern const void* const _MSG_BUTTON_LABEL_REMEMBER; +extern const void* const _MSG_BUTTON_SHORTCUT_REMEMBER; +extern const void* const _MSG_HELP_REMEMBER; +extern const void* const _MSG_BUTTON_LABEL_AUTOSCROLL; +extern const void* const _MSG_BUTTON_SHORTCUT_AUTOSCROLL; +extern const void* const _MSG_HELP_AUTOSCROLL; +extern const void* const _MSG_TAB_EXAMPLE; +extern const void* const _MSG_HELP_LISTVIEW_EXAMPLE; +extern const void* const _MSG_BUTTON_LABEL_EXPAND; +extern const void* const _MSG_BUTTON_SHORTCUT_EXPAND; +extern const void* const _MSG_BUTTON_LABEL_COLLAPSE; +extern const void* const _MSG_BUTTON_SHORTCUT_COLLAPSE; +extern const void* const _MSG_BUTTON_LABEL_LINETYPES; +extern const void* const _MSG_BUTTON_SHORTCUT_LINETYPES; +extern const void* const _MSG_LINETYPE_DISABLED; +extern const void* const _MSG_LINETYPE_NORMAL; +extern const void* const _MSG_LINETYPE_DOTTED; +extern const void* const _MSG_LINETYPE_SHADOW; +extern const void* const _MSG_LINETYPE_GLOW; +extern const void* const _MSG_HELP_LINETYPES; +extern const void* const _MSG_BUTTON_LABEL_FOLDER; +extern const void* const _MSG_BUTTON_SHORTCUT_FOLDER; +extern const void* const _MSG_WIN_TITLE_FOLDER_IMAGE; +extern const void* const _MSG_HELP_FOLDER_IMAGE; +extern const void* const _MSG_BUTTON_LABEL_FOLDERIMAGE; +extern const void* const _MSG_BUTTON_SHORTCUT_FOLDERIMAGE; +extern const void* const _MSG_HELP_FOLDERIMAGE; +extern const void* const _MSG_BUTTON_LABEL_INDENTWIDTH; +extern const void* const _MSG_BUTTON_SHORTCUT_INDENTWIDTH; +extern const void* const _MSG_HELP_INDENTWIDTH; +extern const void* const _MSG_BUTTON_LABEL_GLOW; +extern const void* const _MSG_BUTTON_SHORTCUT_GLOW; +extern const void* const _MSG_WIN_TITLE_GLOW_COLOR; +extern const void* const _MSG_HELP_GLOW_COLOR; + +// substiting defines to directly use MSG_XXXXX strings +#define MSG_Space ((const void* const)1) +#define MSG_TAB_LAYOUT ((const void* const)&_MSG_TAB_LAYOUT) +#define MSG_GROUP_IMAGES_COLORS ((const void* const)&_MSG_GROUP_IMAGES_COLORS) +#define MSG_BUTTON_LABEL_CLOSED ((const void* const)&_MSG_BUTTON_LABEL_CLOSED) +#define MSG_BUTTON_SHORTCUT_CLOSED ((const void* const)&_MSG_BUTTON_SHORTCUT_CLOSED) +#define MSG_HELP_CLOSED_IMAGE ((const void* const)&_MSG_HELP_CLOSED_IMAGE) +#define MSG_WIN_TITLE_CLOSED_IMAGE ((const void* const)&_MSG_WIN_TITLE_CLOSED_IMAGE) +#define MSG_BUTTON_LABEL_LINES ((const void* const)&_MSG_BUTTON_LABEL_LINES) +#define MSG_BUTTON_SHORTCUT_LINES ((const void* const)&_MSG_BUTTON_SHORTCUT_LINES) +#define MSG_HELP_LINES_COLOR ((const void* const)&_MSG_HELP_LINES_COLOR) +#define MSG_WIN_TITLE_LINES_COLOR ((const void* const)&_MSG_WIN_TITLE_LINES_COLOR) +#define MSG_BUTTON_LABEL_OPEN ((const void* const)&_MSG_BUTTON_LABEL_OPEN) +#define MSG_BUTTON_SHORTCUT_OPEN ((const void* const)&_MSG_BUTTON_SHORTCUT_OPEN) +#define MSG_HELP_OPEN_IMAGE ((const void* const)&_MSG_HELP_OPEN_IMAGE) +#define MSG_WIN_TITLE_OPEN_IMAGE ((const void* const)&_MSG_WIN_TITLE_OPEN_IMAGE) +#define MSG_BUTTON_LABEL_SHADOW ((const void* const)&_MSG_BUTTON_LABEL_SHADOW) +#define MSG_BUTTON_SHORTCUT_SHADOW ((const void* const)&_MSG_BUTTON_SHORTCUT_SHADOW) +#define MSG_HELP_SHADOW_COLOR ((const void* const)&_MSG_HELP_SHADOW_COLOR) +#define MSG_WIN_TITLE_SHADOW_COLOR ((const void* const)&_MSG_WIN_TITLE_SHADOW_COLOR) +#define MSG_BUTTON_LABEL_SPECIAL ((const void* const)&_MSG_BUTTON_LABEL_SPECIAL) +#define MSG_BUTTON_SHORTCUT_SPECIAL ((const void* const)&_MSG_BUTTON_SHORTCUT_SPECIAL) +#define MSG_HELP_SPECIAL_IMAGE ((const void* const)&_MSG_HELP_SPECIAL_IMAGE) +#define MSG_WIN_TITLE_SPECIAL_IMAGE ((const void* const)&_MSG_WIN_TITLE_SPECIAL_IMAGE) +#define MSG_BUTTON_LABEL_DRAW ((const void* const)&_MSG_BUTTON_LABEL_DRAW) +#define MSG_BUTTON_SHORTCUT_DRAW ((const void* const)&_MSG_BUTTON_SHORTCUT_DRAW) +#define MSG_HELP_DRAW_COLOR ((const void* const)&_MSG_HELP_DRAW_COLOR) +#define MSG_WIN_TITLE_DRAW_COLOR ((const void* const)&_MSG_WIN_TITLE_DRAW_COLOR) +#define MSG_GROUP_STYLE ((const void* const)&_MSG_GROUP_STYLE) +#define MSG_CYCLE_LABEL_STYLE ((const void* const)&_MSG_CYCLE_LABEL_STYLE) +#define MSG_CYCLE_SHORTCUT_STYLE ((const void* const)&_MSG_CYCLE_SHORTCUT_STYLE) +#define MSG_HELP_STYLE ((const void* const)&_MSG_HELP_STYLE) +#define MSG_CYCLE_ITEM_STYLE_NORMAL ((const void* const)&_MSG_CYCLE_ITEM_STYLE_NORMAL) +#define MSG_CYCLE_ITEM_STYLE_INSERTED ((const void* const)&_MSG_CYCLE_ITEM_STYLE_INSERTED) +#define MSG_CYCLE_ITEM_STYLE_LINES ((const void* const)&_MSG_CYCLE_ITEM_STYLE_LINES) +#define MSG_CYCLE_ITEM_STYLE_WIN98 ((const void* const)&_MSG_CYCLE_ITEM_STYLE_WIN98) +#define MSG_CYCLE_ITEM_STYLE_MAC ((const void* const)&_MSG_CYCLE_ITEM_STYLE_MAC) +#define MSG_CYCLE_ITEM_STYLE_LINES3D ((const void* const)&_MSG_CYCLE_ITEM_STYLE_LINES3D) +#define MSG_CYCLE_ITEM_STYLE_WIN98PLUS ((const void* const)&_MSG_CYCLE_ITEM_STYLE_WIN98PLUS) +#define MSG_CYCLE_ITEM_STYLE_GLOW ((const void* const)&_MSG_CYCLE_ITEM_STYLE_GLOW) +#define MSG_BUTTON_LABEL_SPACE ((const void* const)&_MSG_BUTTON_LABEL_SPACE) +#define MSG_BUTTON_SHORTCUT_SPACE ((const void* const)&_MSG_BUTTON_SHORTCUT_SPACE) +#define MSG_HELP_SPACE ((const void* const)&_MSG_HELP_SPACE) +#define MSG_BUTTON_LABEL_REMEMBER ((const void* const)&_MSG_BUTTON_LABEL_REMEMBER) +#define MSG_BUTTON_SHORTCUT_REMEMBER ((const void* const)&_MSG_BUTTON_SHORTCUT_REMEMBER) +#define MSG_HELP_REMEMBER ((const void* const)&_MSG_HELP_REMEMBER) +#define MSG_BUTTON_LABEL_AUTOSCROLL ((const void* const)&_MSG_BUTTON_LABEL_AUTOSCROLL) +#define MSG_BUTTON_SHORTCUT_AUTOSCROLL ((const void* const)&_MSG_BUTTON_SHORTCUT_AUTOSCROLL) +#define MSG_HELP_AUTOSCROLL ((const void* const)&_MSG_HELP_AUTOSCROLL) +#define MSG_TAB_EXAMPLE ((const void* const)&_MSG_TAB_EXAMPLE) +#define MSG_HELP_LISTVIEW_EXAMPLE ((const void* const)&_MSG_HELP_LISTVIEW_EXAMPLE) +#define MSG_BUTTON_LABEL_EXPAND ((const void* const)&_MSG_BUTTON_LABEL_EXPAND) +#define MSG_BUTTON_SHORTCUT_EXPAND ((const void* const)&_MSG_BUTTON_SHORTCUT_EXPAND) +#define MSG_BUTTON_LABEL_COLLAPSE ((const void* const)&_MSG_BUTTON_LABEL_COLLAPSE) +#define MSG_BUTTON_SHORTCUT_COLLAPSE ((const void* const)&_MSG_BUTTON_SHORTCUT_COLLAPSE) +#define MSG_BUTTON_LABEL_LINETYPES ((const void* const)&_MSG_BUTTON_LABEL_LINETYPES) +#define MSG_BUTTON_SHORTCUT_LINETYPES ((const void* const)&_MSG_BUTTON_SHORTCUT_LINETYPES) +#define MSG_LINETYPE_DISABLED ((const void* const)&_MSG_LINETYPE_DISABLED) +#define MSG_LINETYPE_NORMAL ((const void* const)&_MSG_LINETYPE_NORMAL) +#define MSG_LINETYPE_DOTTED ((const void* const)&_MSG_LINETYPE_DOTTED) +#define MSG_LINETYPE_SHADOW ((const void* const)&_MSG_LINETYPE_SHADOW) +#define MSG_LINETYPE_GLOW ((const void* const)&_MSG_LINETYPE_GLOW) +#define MSG_HELP_LINETYPES ((const void* const)&_MSG_HELP_LINETYPES) +#define MSG_BUTTON_LABEL_FOLDER ((const void* const)&_MSG_BUTTON_LABEL_FOLDER) +#define MSG_BUTTON_SHORTCUT_FOLDER ((const void* const)&_MSG_BUTTON_SHORTCUT_FOLDER) +#define MSG_WIN_TITLE_FOLDER_IMAGE ((const void* const)&_MSG_WIN_TITLE_FOLDER_IMAGE) +#define MSG_HELP_FOLDER_IMAGE ((const void* const)&_MSG_HELP_FOLDER_IMAGE) +#define MSG_BUTTON_LABEL_FOLDERIMAGE ((const void* const)&_MSG_BUTTON_LABEL_FOLDERIMAGE) +#define MSG_BUTTON_SHORTCUT_FOLDERIMAGE ((const void* const)&_MSG_BUTTON_SHORTCUT_FOLDERIMAGE) +#define MSG_HELP_FOLDERIMAGE ((const void* const)&_MSG_HELP_FOLDERIMAGE) +#define MSG_BUTTON_LABEL_INDENTWIDTH ((const void* const)&_MSG_BUTTON_LABEL_INDENTWIDTH) +#define MSG_BUTTON_SHORTCUT_INDENTWIDTH ((const void* const)&_MSG_BUTTON_SHORTCUT_INDENTWIDTH) +#define MSG_HELP_INDENTWIDTH ((const void* const)&_MSG_HELP_INDENTWIDTH) +#define MSG_BUTTON_LABEL_GLOW ((const void* const)&_MSG_BUTTON_LABEL_GLOW) +#define MSG_BUTTON_SHORTCUT_GLOW ((const void* const)&_MSG_BUTTON_SHORTCUT_GLOW) +#define MSG_WIN_TITLE_GLOW_COLOR ((const void* const)&_MSG_WIN_TITLE_GLOW_COLOR) +#define MSG_HELP_GLOW_COLOR ((const void* const)&_MSG_HELP_GLOW_COLOR) + +#endif /* NListtree_mcp_LOCALE_H */ diff --git a/workbench/classes/zune/nlist/nlistviews_mcp/locale.c b/workbench/classes/zune/nlist/nlistviews_mcp/locale.c new file mode 100644 index 00000000000..adb70511964 --- /dev/null +++ b/workbench/classes/zune/nlist/nlistviews_mcp/locale.c @@ -0,0 +1,226 @@ +/*************************************************************************** + + NListviews.mcp - New Listview MUI Custom Class Preferences + Registered MUI class, Serial Number: 1d51 (0x9d510001 to 0x9d51001F + and 0x9d510101 to 0x9d51013F) + + Copyright (C) 1996-2001 by Gilles Masson + Copyright (C) 2001-2014 NList Open Source Team + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + NList classes Support Site: http://www.sf.net/projects/nlist-classes + + $Id: C_c.sd 716 2014-01-26 09:32:35Z damato $ + +***************************************************************************/ + + /* + * If this file is named 'locale.c' it is automatically + * generated by 'FlexCat' from C_c.sd. PLEASE DO NOT EDIT!!! + */ + +#include + +#include +#include "Debug.h" + +struct FC_Type { const long ID; const char * const Str; }; + +const struct FC_Type _MSG_FONTS = { 0, "Fonts" }; +const struct FC_Type _MSG_NORMAL_FONT = { 1, "Normal Font:" }; +const struct FC_Type _MSG_NORMAL_FONT_HELP = { 2, "Choose the normal NList font." }; +const struct FC_Type _MSG_NORMAL_FONT_ASL = { 3, "Please select the normal font..." }; +const struct FC_Type _MSG_SMALL_FONT = { 4, "Small Font:" }; +const struct FC_Type _MSG_SMALL_FONT_HELP = { 5, "Choose the small NList font." }; +const struct FC_Type _MSG_SMALL_FONT_ASL = { 6, "Please select a small font..." }; +const struct FC_Type _MSG_FIXED_FONT = { 7, "Fixed Font:" }; +const struct FC_Type _MSG_FIXED_FONT_HELP = { 8, "Choose the fixed NList font." }; +const struct FC_Type _MSG_FIXED_FONT_ASL = { 9, "Please select a fixed font..." }; +const struct FC_Type _MSG_FONT_MARGIN = { 10, "Font Margin:" }; +const struct FC_Type _MSG_FONT_MARGIN_HELP = { 11, "Allows to set a vertical margin\nwhich will be added to the font\nheight and result in the default\nline height in an NList object." }; +const struct FC_Type _MSG_COLORS = { 12, "Colors" }; +const struct FC_Type _MSG_TEXTCOLOR = { 13, "Text Pen" }; +const struct FC_Type _MSG_BACKGROUNDCOLOR = { 14, "Background" }; +const struct FC_Type _MSG_TITLE_PEN_WIN = { 15, "Title Pen" }; +const struct FC_Type _MSG_TITLE_PEN_HELP = { 16, "For adjusting the pen color of\na title." }; +const struct FC_Type _MSG_PBG_TITLE = { 17, "\033cTitle" }; +const struct FC_Type _MSG_TITLE_BG_WIN = { 18, "Title Background" }; +const struct FC_Type _MSG_TITLE_BG_HELP = { 19, "For adjusting the background color\nof a title." }; +const struct FC_Type _MSG_LIST_PEN_WIN = { 20, "List Pen" }; +const struct FC_Type _MSG_LIST_PEN_HELP = { 21, "For adjusting the pen color of\na list." }; +const struct FC_Type _MSG_PBG_LIST = { 22, "\033cList" }; +const struct FC_Type _MSG_LIST_BG_WIN = { 23, "List Background" }; +const struct FC_Type _MSG_LIST_BG_HELP = { 24, "For adjusting the background color\nof a list." }; +const struct FC_Type _MSG_SELECT_PEN_WIN = { 25, "Selected Entry" }; +const struct FC_Type _MSG_SELECT_PEN_HELP = { 26, "For adjusting the pen color of\nselected entries." }; +const struct FC_Type _MSG_PBG_SELECT = { 27, "\033cSelected" }; +const struct FC_Type _MSG_SELECT_BG_WIN = { 28, "Selected Entry" }; +const struct FC_Type _MSG_SELECT_BG_HELP = { 29, "For adjusting the background color\nof selected entries." }; +const struct FC_Type _MSG_CURSOR_PEN_WIN = { 30, "Selected Cursor" }; +const struct FC_Type _MSG_CURSOR_PEN_HELP = { 31, "For adjusting the pen color of\na selected cursor." }; +const struct FC_Type _MSG_PBG_CURSOR = { 32, "\033cCursor" }; +const struct FC_Type _MSG_CURSOR_BG_WIN = { 33, "Selected Cursor" }; +const struct FC_Type _MSG_CURSOR_BG_HELP = { 34, "For adjusting the background color\nof a selected cursor." }; +const struct FC_Type _MSG_UNSEL_PEN_WIN = { 35, "Unselected Cursor" }; +const struct FC_Type _MSG_UNSEL_PEN_HELP = { 36, "For adjusting the pen color of\nan unselected cursor." }; +const struct FC_Type _MSG_PBG_UNSEL = { 37, "\033cUnselected" }; +const struct FC_Type _MSG_UNSEL_BG_WIN = { 38, "Unselected Cursor" }; +const struct FC_Type _MSG_UNSEL_BG_HELP = { 39, "For adjusting the background color\nof an unselected cursor." }; +const struct FC_Type _MSG_INACT_PEN_WIN = { 40, "Inactive Cursor" }; +const struct FC_Type _MSG_INACT_PEN_HELP = { 41, "For adjusting the pen color of\nan inactive cursor." }; +const struct FC_Type _MSG_PBG_INACT = { 42, "\033cInactive" }; +const struct FC_Type _MSG_INACT_BG_WIN = { 43, "Inactive Cursor" }; +const struct FC_Type _MSG_INACT_BG_HELP = { 44, "For adjusting the background color\nof an inactive cursor." }; +const struct FC_Type _MSG_MULTISELECT = { 45, "MultiSelection" }; +const struct FC_Type _MSG_MULTISELECT_QUAL = { 46, "via Qualifier" }; +const struct FC_Type _MSG_MULTISELECT_ALWAYS = { 47, "Always" }; +const struct FC_Type _MSG_MULTISELECT_HELP = { 48, "Allows to specify the default\nmultiselection mode." }; +const struct FC_Type _MSG_MMB_MULTISEL = { 49, "MMB multiselection" }; +const struct FC_Type _MSG_MMB_MULTISEL_HELP = { 50, "Set it if you want to use the middle\nmouse button (MMB) as a multiselection\nqualifier." }; +const struct FC_Type _MSG_DRAGDROP = { 51, "Drag&Drop" }; +const struct FC_Type _MSG_DRAGTYPE_IMMEDIATE = { 52, "Immediate" }; +const struct FC_Type _MSG_DRAGTYPE_BORDERS = { 53, "at Borders" }; +const struct FC_Type _MSG_DRAGTYPE_QUALIFIER = { 54, "via Qualifier" }; +const struct FC_Type _MSG_DRAGTYPE_HELP = { 55, "Set the drag mode. 'Immediate' will start\ndrag&drop as soon as you drag an object.\n'at Borders' for showing a drag operation\nas soon as you passed the left/right borders\nand 'via Qualifier' for only allowing to\ndrag&drop via a qualifier key (see 'Keys').\n\n'Immediate' is used only when in no-multiselect\nmode." }; +const struct FC_Type _MSG_DRAG_LINES = { 56, "Visible lines" }; +const struct FC_Type _MSG_DRAG_LINES_HELP = { 57, "Give the max. number of lines\nwhich will be shown when\ndoing drag&drop. If more lines\nare selected, you'll get a message\nsimilar to: 'Dragging xx Items...'." }; +const struct FC_Type _MSG_PAGE_FONTS = { 58, "Fonts" }; +const struct FC_Type _MSG_PAGE_COLORS = { 59, "Colors" }; +const struct FC_Type _MSG_PAGE_OPTIONS = { 60, "Options" }; +const struct FC_Type _MSG_PAGE_SCROLLING = { 61, "Scrolling" }; +const struct FC_Type _MSG_PAGE_KEYBINDINGS = { 62, "Keybindings" }; +const struct FC_Type _MSG_SB_HORIZONTAL = { 63, "Horizontal Scrollbar" }; +const struct FC_Type _MSG_SB_HORIZONTAL_HELP = { 64, "Set the default mode\nfor the horizontal scrollbar.\n(may be overwritten by an\napplication)" }; +const struct FC_Type _MSG_SB_VERTICAL = { 65, "Vertical Scrollbar" }; +const struct FC_Type _MSG_SB_VERTICAL_HELP = { 66, "Set the default mode\nfor the vertical scrollbar.\n(may be overwritten by an\napplication)" }; +const struct FC_Type _MSG_SCROLLCONTROL = { 67, "Scrolling Control" }; +const struct FC_Type _MSG_SMOOTH_SCROLLING = { 68, "Smooth Scrolling" }; +const struct FC_Type _MSG_SMOOTH_SCROLLING_HELP = { 69, "If enabled, smoothing scrolling\nwill be used for NList objects.\nIn addition, by using the 'smooth'\nslider in the normal MUI 'Listview'\nconfiguration page the speed of\nthe smooth scrolling can be controled." }; +const struct FC_Type _MSG_MMB_FASTWHEEL = { 70, "MMB Fast Wheel" }; +const struct FC_Type _MSG_MMB_FASTWHEEL_HELP = { 71, "If enabled, the middle mouse button\ncan be used as a qualifier to perform\na fast scroll wheel action.\n(See 'Keybindings' page as well for\nmore wheel qualifiers)" }; +const struct FC_Type _MSG_WHEEL_STEP = { 72, "Mouse Wheel Step" }; +const struct FC_Type _MSG_WHEEL_STEP_HELP = { 73, "Allows to specify the amount of lines\nthat should be scrolled when using a\nwheel mouse." }; +const struct FC_Type _MSG_WHEEL_FAST = { 74, "Mouse Wheel Fast Step" }; +const struct FC_Type _MSG_WHEEL_FAST_HELP = { 75, "Allows to specify the amount of lines\nthat should be scrolled when using a\nwheel mouse and when the fast wheel\nqualifier is pressed." }; +const struct FC_Type _MSG_LAYOUT = { 76, "Layout" }; +const struct FC_Type _MSG_PARTIAL_COL_MARK = { 77, "Partial column mark" }; +const struct FC_Type _MSG_PARTIAL_COL_MARK_HELP = { 78, "If enabled, a special mark will be drawn\nat the right side of a column in case the\ntext didn't completly fit into it." }; +const struct FC_Type _MSG_PARTIAL_CHARS_DRAWN = { 79, "Partial chars drawn" }; +const struct FC_Type _MSG_PARTIAL_CHARS_DRAWN_HELP = { 80, "If enabled, characters that are not fully\nvisible at the left and right corner of\nan NList object will not be drawn partially." }; +const struct FC_Type _MSG_VERT_CENTERED = { 81, "Vertical centered lines" }; +const struct FC_Type _MSG_VERT_CENTERED_HELP = { 82, "If activated, the text lines are centered\nvertically in a NList object." }; +const struct FC_Type _MSG_BALANCING_COLS = { 83, "Balancing Columns" }; +const struct FC_Type _MSG_BALANCING_COLS_HELP = { 84, "NList permits to change the column width\nvia mouse dragging the column separator in\nthe title bar. The moved bar can be visible\neither only in the title, throughout the\nwhole lines or the column width changes can\nbe made visible instantly." }; +const struct FC_Type _MSG_COLWIDTHDRAG_TITLE = { 85, "Title Bar" }; +const struct FC_Type _MSG_COLWIDTHDRAG_FULLBAR = { 86, "Full Bar" }; +const struct FC_Type _MSG_COLWIDTHDRAG_VISIBLE = { 87, "Visible" }; +const struct FC_Type _MSG_COLOR_OPTIONS = { 88, "Options" }; +const struct FC_Type _MSG_FORCE_SELECT_PEN = { 89, "Force select pen" }; +const struct FC_Type _MSG_FORCE_SELECT_PEN_HELP = { 90, "If enabled, NList will make sure that\nthe 'Selected', 'Cursor' and 'Unselected'\ncolor will be forced." }; +const struct FC_Type _MSG_MULTISEL_MOVEACTIVE = { 91, "Keyboard moves cursor" }; +const struct FC_Type _MSG_MULTISEL_MOVEACTIVE_HELP = { 92, "If enabled, a keyboard use in an NList\nobject will move the active cursor\nrather than the unselected one." }; +const struct FC_Type _MSG_GROUP_MISC = { 93, "Miscellaneous" }; +const struct FC_Type _MSG_GROUP_EXAMPLE = { 94, "Example" }; +const struct FC_Type _MSG_SERMOUSE_FIX = { 95, "Serial Mouse Fix" }; +const struct FC_Type _MSG_SERMOUSE_FIX_HELP = { 96, "If enabled, NList tries to fix common\ndrag&drop issues that are related to using\na serial mouse." }; +const struct FC_Type _MSG_SELECT_POINTER = { 97, "Custom Select Pointer" }; +const struct FC_Type _MSG_SELECT_POINTER_HELP = { 98, "If enabled, and an NList object is in\ncharwise selection mode a custom select\npointer will be displayed instead of the\ndefault workbench mouse pointer image." }; +const struct FC_Type _MSG_BAR_CONTEXTMENU = { 99, "Context Menu" }; +const struct FC_Type _MSG_DEFAULT_CONTEXT_MENU_HELP = { 100, "NList permits to have its default\ncontext menu being disabled or enabled\nor only in case the mouse is at the top\nof the NList object." }; +const struct FC_Type _MSG_SNOOP = { 101, "Snoop" }; +const struct FC_Type _MSG_SNOOP_KEY = { 102, "Start the grab of a hotkey." }; +const struct FC_Type _MSG_BUTTON_INSERT = { 103, "Insert" }; +const struct FC_Type _MSG_BUTTON_INSERT_HELP = { 104, "Allows to insert a new hotkey." }; +const struct FC_Type _MSG_BUTTON_REMOVE = { 105, "Remove" }; +const struct FC_Type _MSG_BUTTON_REMOVE_HELP = { 106, "Allows to remove an existing hotkey." }; +const struct FC_Type _MSG_BUTTON_UPDATEKEYS = { 107, "Update keys" }; +const struct FC_Type _MSG_BUTTON_UPDATEKEYS_HELP = { 108, "Add the default hotkeys for\nthe functions which are not\ncurrently in the list." }; +const struct FC_Type _MSG_BUTTON_DEFAULTKEYS = { 109, "Default keys" }; +const struct FC_Type _MSG_BUTTON_DEFAULTKEYS_HELP = { 110, "Resets all hotkeys to default ones." }; +const struct FC_Type _MSG_FUNC_MULTISELQUAL = { 111, "Multiselect/Block Qualifier" }; +const struct FC_Type _MSG_FUNC_DRAGQUAL = { 112, "Drag&Drop Qualifier" }; +const struct FC_Type _MSG_FUNC_BALANCEQUAL = { 113, "Balance Qualifier" }; +const struct FC_Type _MSG_FUNC_COPYCLIP = { 114, "Copy to clipboard" }; +const struct FC_Type _MSG_FUNC_DEFCOLWIDTH = { 115, "Default width column" }; +const struct FC_Type _MSG_FUNC_DEFALLCOLWIDTH = { 116, "Default width all columns" }; +const struct FC_Type _MSG_FUNC_DEFORDERCOL = { 117, "Default order column" }; +const struct FC_Type _MSG_FUNC_DEFALLORDERCOL = { 118, "Default order all columns" }; +const struct FC_Type _MSG_FUNC_SELECTTOP = { 119, "Select to top" }; +const struct FC_Type _MSG_FUNC_SELECTBOTTOM = { 120, "Select to bottom" }; +const struct FC_Type _MSG_FUNC_SELECTPAGEUP = { 121, "Select to page up" }; +const struct FC_Type _MSG_FUNC_SELECTPAGEDOWN = { 122, "Select to page down" }; +const struct FC_Type _MSG_FUNC_SELECTUP = { 123, "Select up" }; +const struct FC_Type _MSG_FUNC_SELECTDOWN = { 124, "Select down" }; +const struct FC_Type _MSG_FUNC_TOGGLEACTIVE = { 125, "Toggle active" }; +const struct FC_Type _MSG_FUNC_FASTWHEELQUAL = { 126, "Fast MouseWheel Qualifier" }; +const struct FC_Type _MSG_FUNC_HORIZWHEELQUAL = { 127, "Horiz MouseWheel Qualifier" }; +const struct FC_Type _MSG_FUNC_TITLECLICKQUAL = { 128, "Title Click Qualifier" }; +const struct FC_Type _MSG_VSB_ALWAYS = { 129, "Always" }; +const struct FC_Type _MSG_VSB_AUTO = { 130, "Auto" }; +const struct FC_Type _MSG_VSB_FULLAUTO = { 131, "FullAuto" }; +const struct FC_Type _MSG_HSB_ALWAYS = { 132, "Always" }; +const struct FC_Type _MSG_HSB_AUTO = { 133, "Auto" }; +const struct FC_Type _MSG_HSB_FULLAUTO = { 134, "FullAuto" }; +const struct FC_Type _MSG_HSB_NONE = { 135, "None" }; +const struct FC_Type _MSG_CMENU_ALWAYS = { 136, "Always" }; +const struct FC_Type _MSG_CMENU_TOPONLY = { 137, "TopOnly" }; +const struct FC_Type _MSG_CMENU_NEVER = { 138, "Never" }; +const struct FC_Type _MSG_HOTKEYS_KEY = { 139, "Key" }; +const struct FC_Type _MSG_HOTKEYS_ACTION = { 140, "Action" }; +const struct FC_Type _MSG_EXAMPLE_TEXT = { 141, "If you have problems, try to increase the stack value,\nin the icon infos if you launch the program from icon,\nstack of CLI if you start it from CLI/Shell,\nand if you launch it from some utility read its docs\nto see how to increase it.\nA stack of 12Kb, 16Kb or 20Kb is most of time a good idea.\n\nIf you still have problems, try to see if they happen with the Demo prog, then tell me.\n\033C\nLatest public release can be found on aminet (dev/mui).\nAll releases are available on\nhttp://www.sourceforge.net/projects/nlist-classes/\n\033C\n\033r\0333(C) 2001-2013 by NList Open Source Team\n\033r\0333(C) 1996-1998 by Gilles Masson\n\033r\0333http://www.sourceforge.net/projects/nlist-classes/\n\033C\n\033cThis new list/listview custom class\n\033chandles its own configurable backgrounds,\n\033cpens, fonts, scrollbars, keys and qualifiers\n\033C\n\033cThe way used to handle cursor with multiselection\n\033cis not exactly as the listview one !\n\033cDrag&Drop is supported, both scrollbars\n\033ccan be configured to disappear automatically\n\033cwhen not needed because all is visible.\n\033cJust try it...\n\033C\n\033cYou can horizontaly scroll with cursor keys,\n\033cor going on the right and left of the list\n\033cwhile selecting with the mouse.\n\033cTry just clicking on the left/right borders !\n\033C\n\033cYou can change columns widths just dragging\n\033cthe vertical separator between columns titles\n\033c(try it using the balancing qualifier too).\n\033C\n\033cYou can change columns order just dragging\n\033cthe column titles.\n\033C\n\033cThere is builtin copy to clipboard stuff\n\033cand classic char selection capability.\n\033C\n\033cTry the Demo program to test all that...\n\n\n\033r\033bGive some feedback about it ! :-)\n\033C\n**************************************************************************************************\n" }; + +static struct Catalog *NL_Catalog = NULL; + +/*** Catalog functions ***/ +/// tr() +const char *tr(const void *fcstr) +{ + const char *defaultstr = ((struct FC_Type *)fcstr)->Str; + + if(LocaleBase) + return (const char *)GetCatalogStr(NL_Catalog, ((struct FC_Type *)fcstr)->ID, (STRPTR)defaultstr); + + return defaultstr; +} +/// +/// CloseCat() +void CloseCat(void) +{ + ENTER(); + + if(NL_Catalog) + { + CloseCatalog(NL_Catalog); + NL_Catalog = NULL; + } + + LEAVE(); +} +/// +/// OpenCat(void) +BOOL OpenCat(void) +{ + static const struct TagItem tags[] = { + { OC_BuiltInLanguage, (IPTR)"english" }, + { OC_Version, 2 }, + { TAG_DONE, 0 } + }; + + ENTER(); + + if(LocaleBase && NL_Catalog == NULL) + NL_Catalog = OpenCatalogA(NULL, (STRPTR)"NListviews_mcp.catalog", (struct TagItem *)&tags[0]); + + RETURN((BOOL)(NL_Catalog != NULL)); + return (BOOL)(NL_Catalog != NULL); +} +/// diff --git a/workbench/classes/zune/nlist/nlistviews_mcp/locale.h b/workbench/classes/zune/nlist/nlistviews_mcp/locale.h new file mode 100644 index 00000000000..305c7e54655 --- /dev/null +++ b/workbench/classes/zune/nlist/nlistviews_mcp/locale.h @@ -0,0 +1,328 @@ +/*************************************************************************** + + NListviews.mcp - New Listview MUI Custom Class Preferences + Registered MUI class, Serial Number: 1d51 (0x9d510001 to 0x9d51001F + and 0x9d510101 to 0x9d51013F) + + Copyright (C) 1996-2001 by Gilles Masson + Copyright (C) 2001-2014 NList Open Source Team + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + NList classes Support Site: http://www.sf.net/projects/nlist-classes + + $Id: C_h.sd 716 2014-01-26 09:32:35Z damato $ + +***************************************************************************/ + + /* + * If this file is named 'locale.h' it is automatically + * generated by 'FlexCat' from C_h.sd. PLEASE DO NOT EDIT!!! + */ + +#ifndef NListviews_mcp_LOCALE_H +#define NListviews_mcp_LOCALE_H + +// catalog translation functions +extern const char *tr(const void *); +extern BOOL OpenCat(void); +extern void CloseCat(void); + +// const pointers to internal strings +extern const void* const _MSG_FONTS; +extern const void* const _MSG_NORMAL_FONT; +extern const void* const _MSG_NORMAL_FONT_HELP; +extern const void* const _MSG_NORMAL_FONT_ASL; +extern const void* const _MSG_SMALL_FONT; +extern const void* const _MSG_SMALL_FONT_HELP; +extern const void* const _MSG_SMALL_FONT_ASL; +extern const void* const _MSG_FIXED_FONT; +extern const void* const _MSG_FIXED_FONT_HELP; +extern const void* const _MSG_FIXED_FONT_ASL; +extern const void* const _MSG_FONT_MARGIN; +extern const void* const _MSG_FONT_MARGIN_HELP; +extern const void* const _MSG_COLORS; +extern const void* const _MSG_TEXTCOLOR; +extern const void* const _MSG_BACKGROUNDCOLOR; +extern const void* const _MSG_TITLE_PEN_WIN; +extern const void* const _MSG_TITLE_PEN_HELP; +extern const void* const _MSG_PBG_TITLE; +extern const void* const _MSG_TITLE_BG_WIN; +extern const void* const _MSG_TITLE_BG_HELP; +extern const void* const _MSG_LIST_PEN_WIN; +extern const void* const _MSG_LIST_PEN_HELP; +extern const void* const _MSG_PBG_LIST; +extern const void* const _MSG_LIST_BG_WIN; +extern const void* const _MSG_LIST_BG_HELP; +extern const void* const _MSG_SELECT_PEN_WIN; +extern const void* const _MSG_SELECT_PEN_HELP; +extern const void* const _MSG_PBG_SELECT; +extern const void* const _MSG_SELECT_BG_WIN; +extern const void* const _MSG_SELECT_BG_HELP; +extern const void* const _MSG_CURSOR_PEN_WIN; +extern const void* const _MSG_CURSOR_PEN_HELP; +extern const void* const _MSG_PBG_CURSOR; +extern const void* const _MSG_CURSOR_BG_WIN; +extern const void* const _MSG_CURSOR_BG_HELP; +extern const void* const _MSG_UNSEL_PEN_WIN; +extern const void* const _MSG_UNSEL_PEN_HELP; +extern const void* const _MSG_PBG_UNSEL; +extern const void* const _MSG_UNSEL_BG_WIN; +extern const void* const _MSG_UNSEL_BG_HELP; +extern const void* const _MSG_INACT_PEN_WIN; +extern const void* const _MSG_INACT_PEN_HELP; +extern const void* const _MSG_PBG_INACT; +extern const void* const _MSG_INACT_BG_WIN; +extern const void* const _MSG_INACT_BG_HELP; +extern const void* const _MSG_MULTISELECT; +extern const void* const _MSG_MULTISELECT_QUAL; +extern const void* const _MSG_MULTISELECT_ALWAYS; +extern const void* const _MSG_MULTISELECT_HELP; +extern const void* const _MSG_MMB_MULTISEL; +extern const void* const _MSG_MMB_MULTISEL_HELP; +extern const void* const _MSG_DRAGDROP; +extern const void* const _MSG_DRAGTYPE_IMMEDIATE; +extern const void* const _MSG_DRAGTYPE_BORDERS; +extern const void* const _MSG_DRAGTYPE_QUALIFIER; +extern const void* const _MSG_DRAGTYPE_HELP; +extern const void* const _MSG_DRAG_LINES; +extern const void* const _MSG_DRAG_LINES_HELP; +extern const void* const _MSG_PAGE_FONTS; +extern const void* const _MSG_PAGE_COLORS; +extern const void* const _MSG_PAGE_OPTIONS; +extern const void* const _MSG_PAGE_SCROLLING; +extern const void* const _MSG_PAGE_KEYBINDINGS; +extern const void* const _MSG_SB_HORIZONTAL; +extern const void* const _MSG_SB_HORIZONTAL_HELP; +extern const void* const _MSG_SB_VERTICAL; +extern const void* const _MSG_SB_VERTICAL_HELP; +extern const void* const _MSG_SCROLLCONTROL; +extern const void* const _MSG_SMOOTH_SCROLLING; +extern const void* const _MSG_SMOOTH_SCROLLING_HELP; +extern const void* const _MSG_MMB_FASTWHEEL; +extern const void* const _MSG_MMB_FASTWHEEL_HELP; +extern const void* const _MSG_WHEEL_STEP; +extern const void* const _MSG_WHEEL_STEP_HELP; +extern const void* const _MSG_WHEEL_FAST; +extern const void* const _MSG_WHEEL_FAST_HELP; +extern const void* const _MSG_LAYOUT; +extern const void* const _MSG_PARTIAL_COL_MARK; +extern const void* const _MSG_PARTIAL_COL_MARK_HELP; +extern const void* const _MSG_PARTIAL_CHARS_DRAWN; +extern const void* const _MSG_PARTIAL_CHARS_DRAWN_HELP; +extern const void* const _MSG_VERT_CENTERED; +extern const void* const _MSG_VERT_CENTERED_HELP; +extern const void* const _MSG_BALANCING_COLS; +extern const void* const _MSG_BALANCING_COLS_HELP; +extern const void* const _MSG_COLWIDTHDRAG_TITLE; +extern const void* const _MSG_COLWIDTHDRAG_FULLBAR; +extern const void* const _MSG_COLWIDTHDRAG_VISIBLE; +extern const void* const _MSG_COLOR_OPTIONS; +extern const void* const _MSG_FORCE_SELECT_PEN; +extern const void* const _MSG_FORCE_SELECT_PEN_HELP; +extern const void* const _MSG_MULTISEL_MOVEACTIVE; +extern const void* const _MSG_MULTISEL_MOVEACTIVE_HELP; +extern const void* const _MSG_GROUP_MISC; +extern const void* const _MSG_GROUP_EXAMPLE; +extern const void* const _MSG_SERMOUSE_FIX; +extern const void* const _MSG_SERMOUSE_FIX_HELP; +extern const void* const _MSG_SELECT_POINTER; +extern const void* const _MSG_SELECT_POINTER_HELP; +extern const void* const _MSG_BAR_CONTEXTMENU; +extern const void* const _MSG_DEFAULT_CONTEXT_MENU_HELP; +extern const void* const _MSG_SNOOP; +extern const void* const _MSG_SNOOP_KEY; +extern const void* const _MSG_BUTTON_INSERT; +extern const void* const _MSG_BUTTON_INSERT_HELP; +extern const void* const _MSG_BUTTON_REMOVE; +extern const void* const _MSG_BUTTON_REMOVE_HELP; +extern const void* const _MSG_BUTTON_UPDATEKEYS; +extern const void* const _MSG_BUTTON_UPDATEKEYS_HELP; +extern const void* const _MSG_BUTTON_DEFAULTKEYS; +extern const void* const _MSG_BUTTON_DEFAULTKEYS_HELP; +extern const void* const _MSG_FUNC_MULTISELQUAL; +extern const void* const _MSG_FUNC_DRAGQUAL; +extern const void* const _MSG_FUNC_BALANCEQUAL; +extern const void* const _MSG_FUNC_COPYCLIP; +extern const void* const _MSG_FUNC_DEFCOLWIDTH; +extern const void* const _MSG_FUNC_DEFALLCOLWIDTH; +extern const void* const _MSG_FUNC_DEFORDERCOL; +extern const void* const _MSG_FUNC_DEFALLORDERCOL; +extern const void* const _MSG_FUNC_SELECTTOP; +extern const void* const _MSG_FUNC_SELECTBOTTOM; +extern const void* const _MSG_FUNC_SELECTPAGEUP; +extern const void* const _MSG_FUNC_SELECTPAGEDOWN; +extern const void* const _MSG_FUNC_SELECTUP; +extern const void* const _MSG_FUNC_SELECTDOWN; +extern const void* const _MSG_FUNC_TOGGLEACTIVE; +extern const void* const _MSG_FUNC_FASTWHEELQUAL; +extern const void* const _MSG_FUNC_HORIZWHEELQUAL; +extern const void* const _MSG_FUNC_TITLECLICKQUAL; +extern const void* const _MSG_VSB_ALWAYS; +extern const void* const _MSG_VSB_AUTO; +extern const void* const _MSG_VSB_FULLAUTO; +extern const void* const _MSG_HSB_ALWAYS; +extern const void* const _MSG_HSB_AUTO; +extern const void* const _MSG_HSB_FULLAUTO; +extern const void* const _MSG_HSB_NONE; +extern const void* const _MSG_CMENU_ALWAYS; +extern const void* const _MSG_CMENU_TOPONLY; +extern const void* const _MSG_CMENU_NEVER; +extern const void* const _MSG_HOTKEYS_KEY; +extern const void* const _MSG_HOTKEYS_ACTION; +extern const void* const _MSG_EXAMPLE_TEXT; + +// substiting defines to directly use MSG_XXXXX strings +#define MSG_Space ((const void* const)1) +#define MSG_FONTS ((const void* const)&_MSG_FONTS) +#define MSG_NORMAL_FONT ((const void* const)&_MSG_NORMAL_FONT) +#define MSG_NORMAL_FONT_HELP ((const void* const)&_MSG_NORMAL_FONT_HELP) +#define MSG_NORMAL_FONT_ASL ((const void* const)&_MSG_NORMAL_FONT_ASL) +#define MSG_SMALL_FONT ((const void* const)&_MSG_SMALL_FONT) +#define MSG_SMALL_FONT_HELP ((const void* const)&_MSG_SMALL_FONT_HELP) +#define MSG_SMALL_FONT_ASL ((const void* const)&_MSG_SMALL_FONT_ASL) +#define MSG_FIXED_FONT ((const void* const)&_MSG_FIXED_FONT) +#define MSG_FIXED_FONT_HELP ((const void* const)&_MSG_FIXED_FONT_HELP) +#define MSG_FIXED_FONT_ASL ((const void* const)&_MSG_FIXED_FONT_ASL) +#define MSG_FONT_MARGIN ((const void* const)&_MSG_FONT_MARGIN) +#define MSG_FONT_MARGIN_HELP ((const void* const)&_MSG_FONT_MARGIN_HELP) +#define MSG_COLORS ((const void* const)&_MSG_COLORS) +#define MSG_TEXTCOLOR ((const void* const)&_MSG_TEXTCOLOR) +#define MSG_BACKGROUNDCOLOR ((const void* const)&_MSG_BACKGROUNDCOLOR) +#define MSG_TITLE_PEN_WIN ((const void* const)&_MSG_TITLE_PEN_WIN) +#define MSG_TITLE_PEN_HELP ((const void* const)&_MSG_TITLE_PEN_HELP) +#define MSG_PBG_TITLE ((const void* const)&_MSG_PBG_TITLE) +#define MSG_TITLE_BG_WIN ((const void* const)&_MSG_TITLE_BG_WIN) +#define MSG_TITLE_BG_HELP ((const void* const)&_MSG_TITLE_BG_HELP) +#define MSG_LIST_PEN_WIN ((const void* const)&_MSG_LIST_PEN_WIN) +#define MSG_LIST_PEN_HELP ((const void* const)&_MSG_LIST_PEN_HELP) +#define MSG_PBG_LIST ((const void* const)&_MSG_PBG_LIST) +#define MSG_LIST_BG_WIN ((const void* const)&_MSG_LIST_BG_WIN) +#define MSG_LIST_BG_HELP ((const void* const)&_MSG_LIST_BG_HELP) +#define MSG_SELECT_PEN_WIN ((const void* const)&_MSG_SELECT_PEN_WIN) +#define MSG_SELECT_PEN_HELP ((const void* const)&_MSG_SELECT_PEN_HELP) +#define MSG_PBG_SELECT ((const void* const)&_MSG_PBG_SELECT) +#define MSG_SELECT_BG_WIN ((const void* const)&_MSG_SELECT_BG_WIN) +#define MSG_SELECT_BG_HELP ((const void* const)&_MSG_SELECT_BG_HELP) +#define MSG_CURSOR_PEN_WIN ((const void* const)&_MSG_CURSOR_PEN_WIN) +#define MSG_CURSOR_PEN_HELP ((const void* const)&_MSG_CURSOR_PEN_HELP) +#define MSG_PBG_CURSOR ((const void* const)&_MSG_PBG_CURSOR) +#define MSG_CURSOR_BG_WIN ((const void* const)&_MSG_CURSOR_BG_WIN) +#define MSG_CURSOR_BG_HELP ((const void* const)&_MSG_CURSOR_BG_HELP) +#define MSG_UNSEL_PEN_WIN ((const void* const)&_MSG_UNSEL_PEN_WIN) +#define MSG_UNSEL_PEN_HELP ((const void* const)&_MSG_UNSEL_PEN_HELP) +#define MSG_PBG_UNSEL ((const void* const)&_MSG_PBG_UNSEL) +#define MSG_UNSEL_BG_WIN ((const void* const)&_MSG_UNSEL_BG_WIN) +#define MSG_UNSEL_BG_HELP ((const void* const)&_MSG_UNSEL_BG_HELP) +#define MSG_INACT_PEN_WIN ((const void* const)&_MSG_INACT_PEN_WIN) +#define MSG_INACT_PEN_HELP ((const void* const)&_MSG_INACT_PEN_HELP) +#define MSG_PBG_INACT ((const void* const)&_MSG_PBG_INACT) +#define MSG_INACT_BG_WIN ((const void* const)&_MSG_INACT_BG_WIN) +#define MSG_INACT_BG_HELP ((const void* const)&_MSG_INACT_BG_HELP) +#define MSG_MULTISELECT ((const void* const)&_MSG_MULTISELECT) +#define MSG_MULTISELECT_QUAL ((const void* const)&_MSG_MULTISELECT_QUAL) +#define MSG_MULTISELECT_ALWAYS ((const void* const)&_MSG_MULTISELECT_ALWAYS) +#define MSG_MULTISELECT_HELP ((const void* const)&_MSG_MULTISELECT_HELP) +#define MSG_MMB_MULTISEL ((const void* const)&_MSG_MMB_MULTISEL) +#define MSG_MMB_MULTISEL_HELP ((const void* const)&_MSG_MMB_MULTISEL_HELP) +#define MSG_DRAGDROP ((const void* const)&_MSG_DRAGDROP) +#define MSG_DRAGTYPE_IMMEDIATE ((const void* const)&_MSG_DRAGTYPE_IMMEDIATE) +#define MSG_DRAGTYPE_BORDERS ((const void* const)&_MSG_DRAGTYPE_BORDERS) +#define MSG_DRAGTYPE_QUALIFIER ((const void* const)&_MSG_DRAGTYPE_QUALIFIER) +#define MSG_DRAGTYPE_HELP ((const void* const)&_MSG_DRAGTYPE_HELP) +#define MSG_DRAG_LINES ((const void* const)&_MSG_DRAG_LINES) +#define MSG_DRAG_LINES_HELP ((const void* const)&_MSG_DRAG_LINES_HELP) +#define MSG_PAGE_FONTS ((const void* const)&_MSG_PAGE_FONTS) +#define MSG_PAGE_COLORS ((const void* const)&_MSG_PAGE_COLORS) +#define MSG_PAGE_OPTIONS ((const void* const)&_MSG_PAGE_OPTIONS) +#define MSG_PAGE_SCROLLING ((const void* const)&_MSG_PAGE_SCROLLING) +#define MSG_PAGE_KEYBINDINGS ((const void* const)&_MSG_PAGE_KEYBINDINGS) +#define MSG_SB_HORIZONTAL ((const void* const)&_MSG_SB_HORIZONTAL) +#define MSG_SB_HORIZONTAL_HELP ((const void* const)&_MSG_SB_HORIZONTAL_HELP) +#define MSG_SB_VERTICAL ((const void* const)&_MSG_SB_VERTICAL) +#define MSG_SB_VERTICAL_HELP ((const void* const)&_MSG_SB_VERTICAL_HELP) +#define MSG_SCROLLCONTROL ((const void* const)&_MSG_SCROLLCONTROL) +#define MSG_SMOOTH_SCROLLING ((const void* const)&_MSG_SMOOTH_SCROLLING) +#define MSG_SMOOTH_SCROLLING_HELP ((const void* const)&_MSG_SMOOTH_SCROLLING_HELP) +#define MSG_MMB_FASTWHEEL ((const void* const)&_MSG_MMB_FASTWHEEL) +#define MSG_MMB_FASTWHEEL_HELP ((const void* const)&_MSG_MMB_FASTWHEEL_HELP) +#define MSG_WHEEL_STEP ((const void* const)&_MSG_WHEEL_STEP) +#define MSG_WHEEL_STEP_HELP ((const void* const)&_MSG_WHEEL_STEP_HELP) +#define MSG_WHEEL_FAST ((const void* const)&_MSG_WHEEL_FAST) +#define MSG_WHEEL_FAST_HELP ((const void* const)&_MSG_WHEEL_FAST_HELP) +#define MSG_LAYOUT ((const void* const)&_MSG_LAYOUT) +#define MSG_PARTIAL_COL_MARK ((const void* const)&_MSG_PARTIAL_COL_MARK) +#define MSG_PARTIAL_COL_MARK_HELP ((const void* const)&_MSG_PARTIAL_COL_MARK_HELP) +#define MSG_PARTIAL_CHARS_DRAWN ((const void* const)&_MSG_PARTIAL_CHARS_DRAWN) +#define MSG_PARTIAL_CHARS_DRAWN_HELP ((const void* const)&_MSG_PARTIAL_CHARS_DRAWN_HELP) +#define MSG_VERT_CENTERED ((const void* const)&_MSG_VERT_CENTERED) +#define MSG_VERT_CENTERED_HELP ((const void* const)&_MSG_VERT_CENTERED_HELP) +#define MSG_BALANCING_COLS ((const void* const)&_MSG_BALANCING_COLS) +#define MSG_BALANCING_COLS_HELP ((const void* const)&_MSG_BALANCING_COLS_HELP) +#define MSG_COLWIDTHDRAG_TITLE ((const void* const)&_MSG_COLWIDTHDRAG_TITLE) +#define MSG_COLWIDTHDRAG_FULLBAR ((const void* const)&_MSG_COLWIDTHDRAG_FULLBAR) +#define MSG_COLWIDTHDRAG_VISIBLE ((const void* const)&_MSG_COLWIDTHDRAG_VISIBLE) +#define MSG_COLOR_OPTIONS ((const void* const)&_MSG_COLOR_OPTIONS) +#define MSG_FORCE_SELECT_PEN ((const void* const)&_MSG_FORCE_SELECT_PEN) +#define MSG_FORCE_SELECT_PEN_HELP ((const void* const)&_MSG_FORCE_SELECT_PEN_HELP) +#define MSG_MULTISEL_MOVEACTIVE ((const void* const)&_MSG_MULTISEL_MOVEACTIVE) +#define MSG_MULTISEL_MOVEACTIVE_HELP ((const void* const)&_MSG_MULTISEL_MOVEACTIVE_HELP) +#define MSG_GROUP_MISC ((const void* const)&_MSG_GROUP_MISC) +#define MSG_GROUP_EXAMPLE ((const void* const)&_MSG_GROUP_EXAMPLE) +#define MSG_SERMOUSE_FIX ((const void* const)&_MSG_SERMOUSE_FIX) +#define MSG_SERMOUSE_FIX_HELP ((const void* const)&_MSG_SERMOUSE_FIX_HELP) +#define MSG_SELECT_POINTER ((const void* const)&_MSG_SELECT_POINTER) +#define MSG_SELECT_POINTER_HELP ((const void* const)&_MSG_SELECT_POINTER_HELP) +#define MSG_BAR_CONTEXTMENU ((const void* const)&_MSG_BAR_CONTEXTMENU) +#define MSG_DEFAULT_CONTEXT_MENU_HELP ((const void* const)&_MSG_DEFAULT_CONTEXT_MENU_HELP) +#define MSG_SNOOP ((const void* const)&_MSG_SNOOP) +#define MSG_SNOOP_KEY ((const void* const)&_MSG_SNOOP_KEY) +#define MSG_BUTTON_INSERT ((const void* const)&_MSG_BUTTON_INSERT) +#define MSG_BUTTON_INSERT_HELP ((const void* const)&_MSG_BUTTON_INSERT_HELP) +#define MSG_BUTTON_REMOVE ((const void* const)&_MSG_BUTTON_REMOVE) +#define MSG_BUTTON_REMOVE_HELP ((const void* const)&_MSG_BUTTON_REMOVE_HELP) +#define MSG_BUTTON_UPDATEKEYS ((const void* const)&_MSG_BUTTON_UPDATEKEYS) +#define MSG_BUTTON_UPDATEKEYS_HELP ((const void* const)&_MSG_BUTTON_UPDATEKEYS_HELP) +#define MSG_BUTTON_DEFAULTKEYS ((const void* const)&_MSG_BUTTON_DEFAULTKEYS) +#define MSG_BUTTON_DEFAULTKEYS_HELP ((const void* const)&_MSG_BUTTON_DEFAULTKEYS_HELP) +#define MSG_FUNC_MULTISELQUAL ((const void* const)&_MSG_FUNC_MULTISELQUAL) +#define MSG_FUNC_DRAGQUAL ((const void* const)&_MSG_FUNC_DRAGQUAL) +#define MSG_FUNC_BALANCEQUAL ((const void* const)&_MSG_FUNC_BALANCEQUAL) +#define MSG_FUNC_COPYCLIP ((const void* const)&_MSG_FUNC_COPYCLIP) +#define MSG_FUNC_DEFCOLWIDTH ((const void* const)&_MSG_FUNC_DEFCOLWIDTH) +#define MSG_FUNC_DEFALLCOLWIDTH ((const void* const)&_MSG_FUNC_DEFALLCOLWIDTH) +#define MSG_FUNC_DEFORDERCOL ((const void* const)&_MSG_FUNC_DEFORDERCOL) +#define MSG_FUNC_DEFALLORDERCOL ((const void* const)&_MSG_FUNC_DEFALLORDERCOL) +#define MSG_FUNC_SELECTTOP ((const void* const)&_MSG_FUNC_SELECTTOP) +#define MSG_FUNC_SELECTBOTTOM ((const void* const)&_MSG_FUNC_SELECTBOTTOM) +#define MSG_FUNC_SELECTPAGEUP ((const void* const)&_MSG_FUNC_SELECTPAGEUP) +#define MSG_FUNC_SELECTPAGEDOWN ((const void* const)&_MSG_FUNC_SELECTPAGEDOWN) +#define MSG_FUNC_SELECTUP ((const void* const)&_MSG_FUNC_SELECTUP) +#define MSG_FUNC_SELECTDOWN ((const void* const)&_MSG_FUNC_SELECTDOWN) +#define MSG_FUNC_TOGGLEACTIVE ((const void* const)&_MSG_FUNC_TOGGLEACTIVE) +#define MSG_FUNC_FASTWHEELQUAL ((const void* const)&_MSG_FUNC_FASTWHEELQUAL) +#define MSG_FUNC_HORIZWHEELQUAL ((const void* const)&_MSG_FUNC_HORIZWHEELQUAL) +#define MSG_FUNC_TITLECLICKQUAL ((const void* const)&_MSG_FUNC_TITLECLICKQUAL) +#define MSG_VSB_ALWAYS ((const void* const)&_MSG_VSB_ALWAYS) +#define MSG_VSB_AUTO ((const void* const)&_MSG_VSB_AUTO) +#define MSG_VSB_FULLAUTO ((const void* const)&_MSG_VSB_FULLAUTO) +#define MSG_HSB_ALWAYS ((const void* const)&_MSG_HSB_ALWAYS) +#define MSG_HSB_AUTO ((const void* const)&_MSG_HSB_AUTO) +#define MSG_HSB_FULLAUTO ((const void* const)&_MSG_HSB_FULLAUTO) +#define MSG_HSB_NONE ((const void* const)&_MSG_HSB_NONE) +#define MSG_CMENU_ALWAYS ((const void* const)&_MSG_CMENU_ALWAYS) +#define MSG_CMENU_TOPONLY ((const void* const)&_MSG_CMENU_TOPONLY) +#define MSG_CMENU_NEVER ((const void* const)&_MSG_CMENU_NEVER) +#define MSG_HOTKEYS_KEY ((const void* const)&_MSG_HOTKEYS_KEY) +#define MSG_HOTKEYS_ACTION ((const void* const)&_MSG_HOTKEYS_ACTION) +#define MSG_EXAMPLE_TEXT ((const void* const)&_MSG_EXAMPLE_TEXT) + +#endif /* NListviews_mcp_LOCALE_H */ diff --git a/workbench/devs/diskimage/device/strings.h b/workbench/devs/diskimage/device/strings.h new file mode 100644 index 00000000000..6b464172639 --- /dev/null +++ b/workbench/devs/diskimage/device/strings.h @@ -0,0 +1,157 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/devs/diskimage/device/catalogs/diskimagedevice.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef DISKIMAGEDEVICE_STRINGS_H +#define DISKIMAGEDEVICE_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_OK_GAD 0 +#define MSG_CANCEL_GAD 1 +#define MSG_PASSWORD_REQ 2 +#define MSG_NOZLIB 3 +#define MSG_NOCAPSDEV 4 +#define MSG_CANCELED 5 +#define MSG_NOPASSWD 6 +#define MSG_WRONGPASSWD 7 +#define MSG_ZLIBERR 8 +#define MSG_CAPSERR 9 +#define MSG_XPKERR 10 +#define MSG_XADERR 11 +#define MSG_UNKNDISKIMGTYPE 12 +#define MSG_UNKNCOMPMETHOD 13 +#define MSG_EOF 14 +#define MSG_BADDATA 15 +#define MSG_BADCRC 16 +#define MSG_BADCHECKSUM 17 +#define MSG_REQ 18 +#define MSG_REQVER 19 +#define MSG_WRONGDAA 20 +#define MSG_EXPATERR 21 +#define MSG_BZLIBERR 22 +#define MSG_UNKNENCRMETHOD 23 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_OK_GAD_STR "_Ok" +#define MSG_CANCEL_GAD_STR "_Cancel" +#define MSG_PASSWORD_REQ_STR "Enter password:" +#define MSG_NOZLIB_STR "z.library required" +#define MSG_NOCAPSDEV_STR "capsimage.device required" +#define MSG_CANCELED_STR "operation canceled" +#define MSG_NOPASSWD_STR "password required" +#define MSG_WRONGPASSWD_STR "wrong password" +#define MSG_ZLIBERR_STR "z.library error" +#define MSG_CAPSERR_STR "capsimage.device error" +#define MSG_XPKERR_STR "xpkmaster.library error" +#define MSG_XADERR_STR "xadmaster.library error" +#define MSG_UNKNDISKIMGTYPE_STR "unsupported disk image type/format" +#define MSG_UNKNCOMPMETHOD_STR "unsupported compression method" +#define MSG_EOF_STR "unexpected end of file" +#define MSG_BADDATA_STR "file contains bad data" +#define MSG_BADCRC_STR "CRC check on file data failed" +#define MSG_BADCHECKSUM_STR "checksum error" +#define MSG_REQ_STR "%s required" +#define MSG_REQVER_STR "%s v%ld or newer required" +#define MSG_WRONGDAA_STR "wrong DAA file (multi-file DAA)" +#define MSG_EXPATERR_STR "expat.library error" +#define MSG_BZLIBERR_STR "bz2.library error" +#define MSG_UNKNENCRMETHOD_STR "unsupported encryption method" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_OK_GAD,(STRPTR)MSG_OK_GAD_STR}, + {MSG_CANCEL_GAD,(STRPTR)MSG_CANCEL_GAD_STR}, + {MSG_PASSWORD_REQ,(STRPTR)MSG_PASSWORD_REQ_STR}, + {MSG_NOZLIB,(STRPTR)MSG_NOZLIB_STR}, + {MSG_NOCAPSDEV,(STRPTR)MSG_NOCAPSDEV_STR}, + {MSG_CANCELED,(STRPTR)MSG_CANCELED_STR}, + {MSG_NOPASSWD,(STRPTR)MSG_NOPASSWD_STR}, + {MSG_WRONGPASSWD,(STRPTR)MSG_WRONGPASSWD_STR}, + {MSG_ZLIBERR,(STRPTR)MSG_ZLIBERR_STR}, + {MSG_CAPSERR,(STRPTR)MSG_CAPSERR_STR}, + {MSG_XPKERR,(STRPTR)MSG_XPKERR_STR}, + {MSG_XADERR,(STRPTR)MSG_XADERR_STR}, + {MSG_UNKNDISKIMGTYPE,(STRPTR)MSG_UNKNDISKIMGTYPE_STR}, + {MSG_UNKNCOMPMETHOD,(STRPTR)MSG_UNKNCOMPMETHOD_STR}, + {MSG_EOF,(STRPTR)MSG_EOF_STR}, + {MSG_BADDATA,(STRPTR)MSG_BADDATA_STR}, + {MSG_BADCRC,(STRPTR)MSG_BADCRC_STR}, + {MSG_BADCHECKSUM,(STRPTR)MSG_BADCHECKSUM_STR}, + {MSG_REQ,(STRPTR)MSG_REQ_STR}, + {MSG_REQVER,(STRPTR)MSG_REQVER_STR}, + {MSG_WRONGDAA,(STRPTR)MSG_WRONGDAA_STR}, + {MSG_EXPATERR,(STRPTR)MSG_EXPATERR_STR}, + {MSG_BZLIBERR,(STRPTR)MSG_BZLIBERR_STR}, + {MSG_UNKNENCRMETHOD,(STRPTR)MSG_UNKNENCRMETHOD_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* DISKIMAGEDEVICE_STRINGS_H */ diff --git a/workbench/devs/diskimage/zune_gui/strings.h b/workbench/devs/diskimage/zune_gui/strings.h new file mode 100644 index 00000000000..57c017e6129 --- /dev/null +++ b/workbench/devs/diskimage/zune_gui/strings.h @@ -0,0 +1,225 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/devs/diskimage/zune_gui/catalogs/diskimagegui.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef DISKIMAGEGUI_STRINGS_H +#define DISKIMAGEGUI_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_UNIT_LBL 0 +#define MSG_DEVICE_LBL 1 +#define MSG_FILENAME_LBL 2 +#define MSG_WRITEPROTECT_LBL 3 +#define MSG_NO_DISK 4 +#define MSG_APPDESCRIPTION 5 +#define MSG_PRIORITY_LBL 50 +#define MSG_PLUGIN_LBL 51 +#define MSG_PLUGIN_GAD 52 +#define MSG_AUTO_LBL 53 +#define MSG_WRITESUPPORT_LBL 54 +#define MSG_PROJECT_ABOUT 100 +#define MSG_PROJECT_HIDE 101 +#define MSG_PROJECT_ICONIFY 102 +#define MSG_PROJECT_SNAPSHOT 103 +#define MSG_PROJECT_QUIT 104 +#define MSG_SETTINGS_MENU 105 +#define MSG_SETTINGS_CHANGETEMPDIR 106 +#define MSG_SETTINGS_SAVE 107 +#define MSG_SETTINGS_PLUGINS 108 +#define MSG_PROJECT_CLOSE 109 +#define MSG_OK_GAD 200 +#define MSG_ABOUT_REQ 201 +#define MSG_ERROR 202 +#define MSG_NOAISS_REQ 203 +#define MSG_OLDAISS_REQ 204 +#define MSG_IMAGENOTFOUND_REQ 205 +#define MSG_CANCEL_GAD 206 +#define MSG_SAVE_GAD 207 +#define MSG_USE_GAD 208 +#define MSG_INSERT_GAD 300 +#define MSG_EJECT_GAD 301 +#define MSG_WRITEPROTECT_GAD 302 +#define MSG_REFRESH_GAD 303 +#define MSG_PLUGINS_WND 304 +#define MSG_MAIN_WND 305 +#define MSG_ABOUT_WND 306 +#define MSG_ERROR_WND 307 +#define MSG_SETDEVICETYPE_GAD 308 +#define MSG_SETDEVICETYPE_WND 309 +#define MSG_DEVICETYPE_GAD 310 +#define MSG_DEVICETYPE_DIRECT_ACCESS 311 +#define MSG_DEVICETYPE_CDROM 312 +#define MSG_DEVICETYPE_OPTICAL_DISK 313 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_UNIT_LBL_STR "Unit" +#define MSG_DEVICE_LBL_STR "Device" +#define MSG_FILENAME_LBL_STR "Disk Image" +#define MSG_WRITEPROTECT_LBL_STR "WP" +#define MSG_NO_DISK_STR "No disk present" +#define MSG_APPDESCRIPTION_STR "Control GUI for diskimage.device" +#define MSG_PRIORITY_LBL_STR "Pri" +#define MSG_PLUGIN_LBL_STR "Plugin" +#define MSG_PLUGIN_GAD_STR "Use plugin" +#define MSG_AUTO_LBL_STR "(Auto)" +#define MSG_WRITESUPPORT_LBL_STR "W" +#define MSG_PROJECT_ABOUT_STR "About..." +#define MSG_PROJECT_HIDE_STR "Hide" +#define MSG_PROJECT_ICONIFY_STR "Iconify" +#define MSG_PROJECT_SNAPSHOT_STR "Snapshot" +#define MSG_PROJECT_QUIT_STR "Quit" +#define MSG_SETTINGS_MENU_STR "Settings" +#define MSG_SETTINGS_CHANGETEMPDIR_STR "Change temp directory..." +#define MSG_SETTINGS_SAVE_STR "Save settings" +#define MSG_SETTINGS_PLUGINS_STR "Plugins..." +#define MSG_PROJECT_CLOSE_STR "Close" +#define MSG_OK_GAD_STR "Ok" +#define MSG_ABOUT_REQ_STR "%s version %ld.%ld\n"\ + "%s version %ld.%ld\n\n"\ + "Copyright (C) 2007-2010 Fredrik Wikstrom\n"\ + "Website: http://a500.org\n"\ + "E-mail: fredrik@a500.org" +#define MSG_ERROR_STR "Error" +#define MSG_NOAISS_REQ_STR "AISS assign not found.\n\n"\ + "Download and install the latest version\n"\ + "from here: http://masonicons.de" +#define MSG_OLDAISS_REQ_STR "AISS v%ld.%ld or newer required.\n\n"\ + "Download and install the latest version\n"\ + "from here: http://masonicons.de" +#define MSG_IMAGENOTFOUND_REQ_STR "Image file '%s' not found." +#define MSG_CANCEL_GAD_STR "_Cancel" +#define MSG_SAVE_GAD_STR "_Save" +#define MSG_USE_GAD_STR "_Use" +#define MSG_INSERT_GAD_STR "Insert" +#define MSG_EJECT_GAD_STR "Eject" +#define MSG_WRITEPROTECT_GAD_STR "Write Protect" +#define MSG_REFRESH_GAD_STR "Refresh" +#define MSG_PLUGINS_WND_STR "Plugins" +#define MSG_MAIN_WND_STR "%s: Hot Key = <%s>" +#define MSG_ABOUT_WND_STR "About - %s" +#define MSG_ERROR_WND_STR "Error - %s" +#define MSG_SETDEVICETYPE_GAD_STR "Set Device Type" +#define MSG_SETDEVICETYPE_WND_STR "Unit: %ld - Device Type" +#define MSG_DEVICETYPE_GAD_STR "Device Type" +#define MSG_DEVICETYPE_DIRECT_ACCESS_STR "Direct Access (Default setting)" +#define MSG_DEVICETYPE_CDROM_STR "CD-ROM" +#define MSG_DEVICETYPE_OPTICAL_DISK_STR "Optical Disk" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_UNIT_LBL,(STRPTR)MSG_UNIT_LBL_STR}, + {MSG_DEVICE_LBL,(STRPTR)MSG_DEVICE_LBL_STR}, + {MSG_FILENAME_LBL,(STRPTR)MSG_FILENAME_LBL_STR}, + {MSG_WRITEPROTECT_LBL,(STRPTR)MSG_WRITEPROTECT_LBL_STR}, + {MSG_NO_DISK,(STRPTR)MSG_NO_DISK_STR}, + {MSG_APPDESCRIPTION,(STRPTR)MSG_APPDESCRIPTION_STR}, + {MSG_PRIORITY_LBL,(STRPTR)MSG_PRIORITY_LBL_STR}, + {MSG_PLUGIN_LBL,(STRPTR)MSG_PLUGIN_LBL_STR}, + {MSG_PLUGIN_GAD,(STRPTR)MSG_PLUGIN_GAD_STR}, + {MSG_AUTO_LBL,(STRPTR)MSG_AUTO_LBL_STR}, + {MSG_WRITESUPPORT_LBL,(STRPTR)MSG_WRITESUPPORT_LBL_STR}, + {MSG_PROJECT_ABOUT,(STRPTR)MSG_PROJECT_ABOUT_STR}, + {MSG_PROJECT_HIDE,(STRPTR)MSG_PROJECT_HIDE_STR}, + {MSG_PROJECT_ICONIFY,(STRPTR)MSG_PROJECT_ICONIFY_STR}, + {MSG_PROJECT_SNAPSHOT,(STRPTR)MSG_PROJECT_SNAPSHOT_STR}, + {MSG_PROJECT_QUIT,(STRPTR)MSG_PROJECT_QUIT_STR}, + {MSG_SETTINGS_MENU,(STRPTR)MSG_SETTINGS_MENU_STR}, + {MSG_SETTINGS_CHANGETEMPDIR,(STRPTR)MSG_SETTINGS_CHANGETEMPDIR_STR}, + {MSG_SETTINGS_SAVE,(STRPTR)MSG_SETTINGS_SAVE_STR}, + {MSG_SETTINGS_PLUGINS,(STRPTR)MSG_SETTINGS_PLUGINS_STR}, + {MSG_PROJECT_CLOSE,(STRPTR)MSG_PROJECT_CLOSE_STR}, + {MSG_OK_GAD,(STRPTR)MSG_OK_GAD_STR}, + {MSG_ABOUT_REQ,(STRPTR)MSG_ABOUT_REQ_STR}, + {MSG_ERROR,(STRPTR)MSG_ERROR_STR}, + {MSG_NOAISS_REQ,(STRPTR)MSG_NOAISS_REQ_STR}, + {MSG_OLDAISS_REQ,(STRPTR)MSG_OLDAISS_REQ_STR}, + {MSG_IMAGENOTFOUND_REQ,(STRPTR)MSG_IMAGENOTFOUND_REQ_STR}, + {MSG_CANCEL_GAD,(STRPTR)MSG_CANCEL_GAD_STR}, + {MSG_SAVE_GAD,(STRPTR)MSG_SAVE_GAD_STR}, + {MSG_USE_GAD,(STRPTR)MSG_USE_GAD_STR}, + {MSG_INSERT_GAD,(STRPTR)MSG_INSERT_GAD_STR}, + {MSG_EJECT_GAD,(STRPTR)MSG_EJECT_GAD_STR}, + {MSG_WRITEPROTECT_GAD,(STRPTR)MSG_WRITEPROTECT_GAD_STR}, + {MSG_REFRESH_GAD,(STRPTR)MSG_REFRESH_GAD_STR}, + {MSG_PLUGINS_WND,(STRPTR)MSG_PLUGINS_WND_STR}, + {MSG_MAIN_WND,(STRPTR)MSG_MAIN_WND_STR}, + {MSG_ABOUT_WND,(STRPTR)MSG_ABOUT_WND_STR}, + {MSG_ERROR_WND,(STRPTR)MSG_ERROR_WND_STR}, + {MSG_SETDEVICETYPE_GAD,(STRPTR)MSG_SETDEVICETYPE_GAD_STR}, + {MSG_SETDEVICETYPE_WND,(STRPTR)MSG_SETDEVICETYPE_WND_STR}, + {MSG_DEVICETYPE_GAD,(STRPTR)MSG_DEVICETYPE_GAD_STR}, + {MSG_DEVICETYPE_DIRECT_ACCESS,(STRPTR)MSG_DEVICETYPE_DIRECT_ACCESS_STR}, + {MSG_DEVICETYPE_CDROM,(STRPTR)MSG_DEVICETYPE_CDROM_STR}, + {MSG_DEVICETYPE_OPTICAL_DISK,(STRPTR)MSG_DEVICETYPE_OPTICAL_DISK_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* DISKIMAGEGUI_STRINGS_H */ diff --git a/workbench/libs/muimaster/muimaster_strings.h b/workbench/libs/muimaster/muimaster_strings.h new file mode 100644 index 00000000000..bbe85cef16c --- /dev/null +++ b/workbench/libs/muimaster/muimaster_strings.h @@ -0,0 +1,237 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/libs/muimaster/catalogs/muimaster.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef MUIMASTER_STRINGS_H +#define MUIMASTER_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_OK 0 +#define MSG_CANCEL 1 +#define MSG_ABOUTMUI_WINDOW_TITLE 2 +#define MSG_ABOUTMUI_STRING 3 +#define MSG_COLORADJUST_RED 4 +#define MSG_COLORADJUST_GREEN 5 +#define MSG_COLORADJUST_BLUE 6 +#define MSG_DIRLIST_NAME 7 +#define MSG_DIRLIST_SIZE 8 +#define MSG_DIRLIST_DATE 9 +#define MSG_DIRLIST_TIME 10 +#define MSG_DIRLIST_FLAGS 11 +#define MSG_DIRLIST_COMMENT 12 +#define MSG_FRAMEADJUST_INNER_SPACING 13 +#define MSG_FRAMEADJUST_LEFT 14 +#define MSG_FRAMEADJUST_TOP 15 +#define MSG_FRAMEADJUST_RIGHT 16 +#define MSG_FRAMEADJUST_BOTTOM 17 +#define MSG_IMAGEADJUST_PATTERN 18 +#define MSG_IMAGEADJUST_VECTOR 19 +#define MSG_IMAGEADJUST_COLOR 20 +#define MSG_IMAGEADJUST_EXTERNAL 21 +#define MSG_IMAGEADJUST_BITMAP 22 +#define MSG_IMAGEADJUST_GRADIENT 23 +#define MSG_IMAGEADJUST_SCALED 24 +#define MSG_IMAGEADJUST_TILED 25 +#define MSG_IMAGEADJUST_TYPE 26 +#define MSG_IMAGEADJUST_ANGLE 27 +#define MSG_IMAGEADJUST_VERTICAL 28 +#define MSG_IMAGEADJUST_HORIZONTAL 29 +#define MSG_IMAGEADJUST_COLORS 30 +#define MSG_IMAGEADJUST_START_PEN 31 +#define MSG_IMAGEADJUST_END_PEN 32 +#define MSG_IMAGEADJUST_PREVIEW 33 +#define MSG_PALETTE_COLOR 34 +#define MSG_PENADJUST_MUI 35 +#define MSG_PENADJUST_COLORMAP 36 +#define MSG_PENADJUST_RGB 37 +#define MSG_PENADJUST_SHINE 38 +#define MSG_PENADJUST_HALFSHINE 39 +#define MSG_PENADJUST_BACKGROUND 40 +#define MSG_PENADJUST_HALFSHADOW 41 +#define MSG_PENADJUST_SHADOW 42 +#define MSG_PENADJUST_TEXT 43 +#define MSG_PENADJUST_FILL 44 +#define MSG_PENADJUST_MARK 45 +#define MSG_VOLUMELIST_NAME 46 +#define MSG_VOLUMELIST_FULL 47 +#define MSG_VOLUMELIST_FREE 48 +#define MSG_VOLUMELIST_USED 49 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_OK_STR "_Ok" +#define MSG_CANCEL_STR "_Cancel" +#define MSG_ABOUTMUI_WINDOW_TITLE_STR "About Zune" +#define MSG_ABOUTMUI_STRING_STR "Zune, a MUI clone\n\n"\ + "Compiled on %s\n"\ + "Copyright (C) 2002-2020, The AROS Development Team." +#define MSG_COLORADJUST_RED_STR "Red:" +#define MSG_COLORADJUST_GREEN_STR "Green:" +#define MSG_COLORADJUST_BLUE_STR "Blue:" +#define MSG_DIRLIST_NAME_STR "Name" +#define MSG_DIRLIST_SIZE_STR "Size" +#define MSG_DIRLIST_DATE_STR "Date" +#define MSG_DIRLIST_TIME_STR "Time" +#define MSG_DIRLIST_FLAGS_STR "Flags" +#define MSG_DIRLIST_COMMENT_STR "Comment" +#define MSG_FRAMEADJUST_INNER_SPACING_STR "Inner Spacing:" +#define MSG_FRAMEADJUST_LEFT_STR "Left" +#define MSG_FRAMEADJUST_TOP_STR "Top" +#define MSG_FRAMEADJUST_RIGHT_STR "Right" +#define MSG_FRAMEADJUST_BOTTOM_STR "Bottom" +#define MSG_IMAGEADJUST_PATTERN_STR "Pattern" +#define MSG_IMAGEADJUST_VECTOR_STR "Vector" +#define MSG_IMAGEADJUST_COLOR_STR "Color" +#define MSG_IMAGEADJUST_EXTERNAL_STR "External" +#define MSG_IMAGEADJUST_BITMAP_STR "Bitmap" +#define MSG_IMAGEADJUST_GRADIENT_STR "Gradient" +#define MSG_IMAGEADJUST_SCALED_STR "Scaled" +#define MSG_IMAGEADJUST_TILED_STR "Tiled" +#define MSG_IMAGEADJUST_TYPE_STR "Type:" +#define MSG_IMAGEADJUST_ANGLE_STR "Angle:" +#define MSG_IMAGEADJUST_VERTICAL_STR "Vertical" +#define MSG_IMAGEADJUST_HORIZONTAL_STR "Horizontal" +#define MSG_IMAGEADJUST_COLORS_STR "Colors:" +#define MSG_IMAGEADJUST_START_PEN_STR "Start pen" +#define MSG_IMAGEADJUST_END_PEN_STR "End pen" +#define MSG_IMAGEADJUST_PREVIEW_STR "Preview:" +#define MSG_PALETTE_COLOR_STR "Color %ld" +#define MSG_PENADJUST_MUI_STR "MUI" +#define MSG_PENADJUST_COLORMAP_STR "Colormap" +#define MSG_PENADJUST_RGB_STR "RGB" +#define MSG_PENADJUST_SHINE_STR "Shine" +#define MSG_PENADJUST_HALFSHINE_STR "Halfshine" +#define MSG_PENADJUST_BACKGROUND_STR "Background" +#define MSG_PENADJUST_HALFSHADOW_STR "Halfshadow" +#define MSG_PENADJUST_SHADOW_STR "Shadow" +#define MSG_PENADJUST_TEXT_STR "Text" +#define MSG_PENADJUST_FILL_STR "Fill" +#define MSG_PENADJUST_MARK_STR "Mark" +#define MSG_VOLUMELIST_NAME_STR "Name" +#define MSG_VOLUMELIST_FULL_STR "Full" +#define MSG_VOLUMELIST_FREE_STR "Free" +#define MSG_VOLUMELIST_USED_STR "Used" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_CANCEL,(STRPTR)MSG_CANCEL_STR}, + {MSG_ABOUTMUI_WINDOW_TITLE,(STRPTR)MSG_ABOUTMUI_WINDOW_TITLE_STR}, + {MSG_ABOUTMUI_STRING,(STRPTR)MSG_ABOUTMUI_STRING_STR}, + {MSG_COLORADJUST_RED,(STRPTR)MSG_COLORADJUST_RED_STR}, + {MSG_COLORADJUST_GREEN,(STRPTR)MSG_COLORADJUST_GREEN_STR}, + {MSG_COLORADJUST_BLUE,(STRPTR)MSG_COLORADJUST_BLUE_STR}, + {MSG_DIRLIST_NAME,(STRPTR)MSG_DIRLIST_NAME_STR}, + {MSG_DIRLIST_SIZE,(STRPTR)MSG_DIRLIST_SIZE_STR}, + {MSG_DIRLIST_DATE,(STRPTR)MSG_DIRLIST_DATE_STR}, + {MSG_DIRLIST_TIME,(STRPTR)MSG_DIRLIST_TIME_STR}, + {MSG_DIRLIST_FLAGS,(STRPTR)MSG_DIRLIST_FLAGS_STR}, + {MSG_DIRLIST_COMMENT,(STRPTR)MSG_DIRLIST_COMMENT_STR}, + {MSG_FRAMEADJUST_INNER_SPACING,(STRPTR)MSG_FRAMEADJUST_INNER_SPACING_STR}, + {MSG_FRAMEADJUST_LEFT,(STRPTR)MSG_FRAMEADJUST_LEFT_STR}, + {MSG_FRAMEADJUST_TOP,(STRPTR)MSG_FRAMEADJUST_TOP_STR}, + {MSG_FRAMEADJUST_RIGHT,(STRPTR)MSG_FRAMEADJUST_RIGHT_STR}, + {MSG_FRAMEADJUST_BOTTOM,(STRPTR)MSG_FRAMEADJUST_BOTTOM_STR}, + {MSG_IMAGEADJUST_PATTERN,(STRPTR)MSG_IMAGEADJUST_PATTERN_STR}, + {MSG_IMAGEADJUST_VECTOR,(STRPTR)MSG_IMAGEADJUST_VECTOR_STR}, + {MSG_IMAGEADJUST_COLOR,(STRPTR)MSG_IMAGEADJUST_COLOR_STR}, + {MSG_IMAGEADJUST_EXTERNAL,(STRPTR)MSG_IMAGEADJUST_EXTERNAL_STR}, + {MSG_IMAGEADJUST_BITMAP,(STRPTR)MSG_IMAGEADJUST_BITMAP_STR}, + {MSG_IMAGEADJUST_GRADIENT,(STRPTR)MSG_IMAGEADJUST_GRADIENT_STR}, + {MSG_IMAGEADJUST_SCALED,(STRPTR)MSG_IMAGEADJUST_SCALED_STR}, + {MSG_IMAGEADJUST_TILED,(STRPTR)MSG_IMAGEADJUST_TILED_STR}, + {MSG_IMAGEADJUST_TYPE,(STRPTR)MSG_IMAGEADJUST_TYPE_STR}, + {MSG_IMAGEADJUST_ANGLE,(STRPTR)MSG_IMAGEADJUST_ANGLE_STR}, + {MSG_IMAGEADJUST_VERTICAL,(STRPTR)MSG_IMAGEADJUST_VERTICAL_STR}, + {MSG_IMAGEADJUST_HORIZONTAL,(STRPTR)MSG_IMAGEADJUST_HORIZONTAL_STR}, + {MSG_IMAGEADJUST_COLORS,(STRPTR)MSG_IMAGEADJUST_COLORS_STR}, + {MSG_IMAGEADJUST_START_PEN,(STRPTR)MSG_IMAGEADJUST_START_PEN_STR}, + {MSG_IMAGEADJUST_END_PEN,(STRPTR)MSG_IMAGEADJUST_END_PEN_STR}, + {MSG_IMAGEADJUST_PREVIEW,(STRPTR)MSG_IMAGEADJUST_PREVIEW_STR}, + {MSG_PALETTE_COLOR,(STRPTR)MSG_PALETTE_COLOR_STR}, + {MSG_PENADJUST_MUI,(STRPTR)MSG_PENADJUST_MUI_STR}, + {MSG_PENADJUST_COLORMAP,(STRPTR)MSG_PENADJUST_COLORMAP_STR}, + {MSG_PENADJUST_RGB,(STRPTR)MSG_PENADJUST_RGB_STR}, + {MSG_PENADJUST_SHINE,(STRPTR)MSG_PENADJUST_SHINE_STR}, + {MSG_PENADJUST_HALFSHINE,(STRPTR)MSG_PENADJUST_HALFSHINE_STR}, + {MSG_PENADJUST_BACKGROUND,(STRPTR)MSG_PENADJUST_BACKGROUND_STR}, + {MSG_PENADJUST_HALFSHADOW,(STRPTR)MSG_PENADJUST_HALFSHADOW_STR}, + {MSG_PENADJUST_SHADOW,(STRPTR)MSG_PENADJUST_SHADOW_STR}, + {MSG_PENADJUST_TEXT,(STRPTR)MSG_PENADJUST_TEXT_STR}, + {MSG_PENADJUST_FILL,(STRPTR)MSG_PENADJUST_FILL_STR}, + {MSG_PENADJUST_MARK,(STRPTR)MSG_PENADJUST_MARK_STR}, + {MSG_VOLUMELIST_NAME,(STRPTR)MSG_VOLUMELIST_NAME_STR}, + {MSG_VOLUMELIST_FULL,(STRPTR)MSG_VOLUMELIST_FULL_STR}, + {MSG_VOLUMELIST_FREE,(STRPTR)MSG_VOLUMELIST_FREE_STR}, + {MSG_VOLUMELIST_USED,(STRPTR)MSG_VOLUMELIST_USED_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* MUIMASTER_STRINGS_H */ diff --git a/workbench/prefs/appearance/strings.h b/workbench/prefs/appearance/strings.h new file mode 100644 index 00000000000..cf0ebaa6b92 --- /dev/null +++ b/workbench/prefs/appearance/strings.h @@ -0,0 +1,130 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/prefs/appearance/catalogs/appearance.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef APPEARANCE_STRINGS_H +#define APPEARANCE_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_WINTITLE 0 +#define MSG_OK 1 +#define MSG_ENABLETHEMES 2 +#define MSG_PREVIEW 3 +#define MSG_NOPREVIEW 4 +#define MSG_SELECTEDTHEME 5 +#define MSG_ENABLEZUNEPREFS 6 +#define MSG_ENABLEWANDPREFS 7 +#define MSG_SEC_THEMING 8 +#define MSG_SEC_COMPOSITING 9 +#define MSG_ENABLE_SCREEN_COMPOSITION 10 +#define MSG_COMPOSITE_BELOW 11 +#define MSG_COMPOSITE_LEFT 12 +#define MSG_COMPOSITE_RIGHT 13 +#define MSG_ENABLE_COMPOSITE_WITH_ALPHA 14 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_WINTITLE_STR "Appearance Preferences" +#define MSG_OK_STR "Ok" +#define MSG_ENABLETHEMES_STR "Enable theming" +#define MSG_PREVIEW_STR "Preview" +#define MSG_NOPREVIEW_STR "-Preview Unavailable-" +#define MSG_SELECTEDTHEME_STR "Theme:" +#define MSG_ENABLEZUNEPREFS_STR "Override Zune configuration" +#define MSG_ENABLEWANDPREFS_STR "Inherit Wanderer Configuration?" +#define MSG_SEC_THEMING_STR "Theming" +#define MSG_SEC_COMPOSITING_STR "Compositing" +#define MSG_ENABLE_SCREEN_COMPOSITION_STR "Enable screen composition" +#define MSG_COMPOSITE_BELOW_STR "Composite below" +#define MSG_COMPOSITE_LEFT_STR "Composite left" +#define MSG_COMPOSITE_RIGHT_STR "Composite right" +#define MSG_ENABLE_COMPOSITE_WITH_ALPHA_STR "Enable compositing with alpha" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_WINTITLE,(STRPTR)MSG_WINTITLE_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_ENABLETHEMES,(STRPTR)MSG_ENABLETHEMES_STR}, + {MSG_PREVIEW,(STRPTR)MSG_PREVIEW_STR}, + {MSG_NOPREVIEW,(STRPTR)MSG_NOPREVIEW_STR}, + {MSG_SELECTEDTHEME,(STRPTR)MSG_SELECTEDTHEME_STR}, + {MSG_ENABLEZUNEPREFS,(STRPTR)MSG_ENABLEZUNEPREFS_STR}, + {MSG_ENABLEWANDPREFS,(STRPTR)MSG_ENABLEWANDPREFS_STR}, + {MSG_SEC_THEMING,(STRPTR)MSG_SEC_THEMING_STR}, + {MSG_SEC_COMPOSITING,(STRPTR)MSG_SEC_COMPOSITING_STR}, + {MSG_ENABLE_SCREEN_COMPOSITION,(STRPTR)MSG_ENABLE_SCREEN_COMPOSITION_STR}, + {MSG_COMPOSITE_BELOW,(STRPTR)MSG_COMPOSITE_BELOW_STR}, + {MSG_COMPOSITE_LEFT,(STRPTR)MSG_COMPOSITE_LEFT_STR}, + {MSG_COMPOSITE_RIGHT,(STRPTR)MSG_COMPOSITE_RIGHT_STR}, + {MSG_ENABLE_COMPOSITE_WITH_ALPHA,(STRPTR)MSG_ENABLE_COMPOSITE_WITH_ALPHA_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* APPEARANCE_STRINGS_H */ diff --git a/workbench/prefs/boingiconbar/strings.h b/workbench/prefs/boingiconbar/strings.h new file mode 100644 index 00000000000..a697ecf7b64 --- /dev/null +++ b/workbench/prefs/boingiconbar/strings.h @@ -0,0 +1,118 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/prefs/boingiconbar/catalogs/boingiconbar.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef BOINGICONBAR_STRINGS_H +#define BOINGICONBAR_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_APP 0 +#define MSG_DESCRIPTION 1 +#define MSG_TITLE 2 +#define MSG_DOCK 3 +#define MSG_ADD_DOCK 4 +#define MSG_DEL_DOCK 5 +#define MSG_SAVE 6 +#define MSG_PROGRAMS 7 +#define MSG_ADD_P 8 +#define MSG_DEL_P 9 +#define MSG_OK 10 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_APP_STR "BIBPrefs" +#define MSG_DESCRIPTION_STR "BoingIconBar Preferences" +#define MSG_TITLE_STR "BoingIconBar Preferences" +#define MSG_DOCK_STR "\033cDock" +#define MSG_ADD_DOCK_STR "Add" +#define MSG_DEL_DOCK_STR "Delete" +#define MSG_SAVE_STR "Save" +#define MSG_PROGRAMS_STR "\033cPrograms" +#define MSG_ADD_P_STR "Add program" +#define MSG_DEL_P_STR "Del program" +#define MSG_OK_STR "OK" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_APP,(STRPTR)MSG_APP_STR}, + {MSG_DESCRIPTION,(STRPTR)MSG_DESCRIPTION_STR}, + {MSG_TITLE,(STRPTR)MSG_TITLE_STR}, + {MSG_DOCK,(STRPTR)MSG_DOCK_STR}, + {MSG_ADD_DOCK,(STRPTR)MSG_ADD_DOCK_STR}, + {MSG_DEL_DOCK,(STRPTR)MSG_DEL_DOCK_STR}, + {MSG_SAVE,(STRPTR)MSG_SAVE_STR}, + {MSG_PROGRAMS,(STRPTR)MSG_PROGRAMS_STR}, + {MSG_ADD_P,(STRPTR)MSG_ADD_P_STR}, + {MSG_DEL_P,(STRPTR)MSG_DEL_P_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* BOINGICONBAR_STRINGS_H */ diff --git a/workbench/prefs/printer/strings.h b/workbench/prefs/printer/strings.h new file mode 100644 index 00000000000..05cce0c55f1 --- /dev/null +++ b/workbench/prefs/printer/strings.h @@ -0,0 +1,244 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/prefs/printer/catalogs/printer.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef PRINTER_STRINGS_H +#define PRINTER_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_WINTITLE 0 +#define MSG_OK 1 +#define MSG_PRINTER_DRIVER 2 +#define MSG_PRINTER_SETTINGS 3 +#define MSG_PRINTER_SELECT_DRIVER 4 +#define MSG_PRINTER_NAME 5 +#define MSG_PRINTER_UNIT 6 +#define MSG_PRINTER_PS_UNIT 7 +#define MSG_PRINTER_CUSTOM_DEVICE 8 +#define MSG_PRINTER_DEVICE_UNIT 9 +#define MSG_PRINTER_PARALLEL 10 +#define MSG_PRINTER_SERIAL 11 +#define MSG_PRINTER_TO_FILE 12 +#define MSG_PRINTER_USB 13 +#define MSG_TISK_PAPER_TYPE 14 +#define MSG_TISK_PAPER_SIZE 15 +#define MSG_TISK_QUALITY 16 +#define MSG_TISK_PITCH 17 +#define MSG_TISK_SPACING 18 +#define MSG_TISK_LEFT_MARGIN 19 +#define MSG_TISK_RIGHT_MARGIN 20 +#define MSG_TISK_LINE_PER_PAGE 21 +#define MSG_TISK_DENSITY 22 +#define MSG_TISK_ASPECT 23 +#define MSG_TISK_SHADE 24 +#define MSG_TISK_IMAGE 25 +#define MSG_TISK_TRESHOLD 26 +#define MSG_TISK_DITHERING 27 +#define MSG_TISK_DIMENSION 28 +#define MSG_TISK_PAPER_OFFSET 29 +#define MSG_TISK_CENTER_IMAGE 30 +#define MSG_TISK_ANTIALIAS 31 +#define MSG_TISK_INTEGER_SCALING 32 +#define MSG_TISK_FANFOLD 33 +#define MSG_TISK_SINGLE 34 +#define MSG_TISK_DRAFT 35 +#define MSG_TISK_LETTER 36 +#define MSG_TISK_PORTRAIT 37 +#define MSG_TISK_LANDSCAPE 38 +#define MSG_TISK_BW 39 +#define MSG_TISK_GRAY 40 +#define MSG_TISK_COLOR 41 +#define MSG_TISK_GRAY2 42 +#define MSG_TISK_POSITIVE 43 +#define MSG_TISK_NEGATIVE 44 +#define MSG_TISK_IGNORE 45 +#define MSG_TISK_BOUNDED 46 +#define MSG_TISK_ABSOLUTE 47 +#define MSG_TISK_PIXEL 48 +#define MSG_TISK_MULTIPLY 49 +#define MSG_TISK_ORDERED 50 +#define MSG_TISK_HALFTONE 51 +#define MSG_TISK_FLOYDSTEINBERG 52 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_WINTITLE_STR "Printer Preferences" +#define MSG_OK_STR "Ok" +#define MSG_PRINTER_DRIVER_STR "Driver" +#define MSG_PRINTER_SETTINGS_STR "Settings" +#define MSG_PRINTER_SELECT_DRIVER_STR "Select Driver:" +#define MSG_PRINTER_NAME_STR "Name:" +#define MSG_PRINTER_UNIT_STR "Printer Unit:" +#define MSG_PRINTER_PS_UNIT_STR "Unit:" +#define MSG_PRINTER_CUSTOM_DEVICE_STR "Custom device:" +#define MSG_PRINTER_DEVICE_UNIT_STR "Unit %d" +#define MSG_PRINTER_PARALLEL_STR "Parallel" +#define MSG_PRINTER_SERIAL_STR "Serial" +#define MSG_PRINTER_TO_FILE_STR "Print to file" +#define MSG_PRINTER_USB_STR "USB Printer" +#define MSG_TISK_PAPER_TYPE_STR "Paper Type:" +#define MSG_TISK_PAPER_SIZE_STR "Paper Size:" +#define MSG_TISK_QUALITY_STR "Quality:" +#define MSG_TISK_PITCH_STR "Pitch:" +#define MSG_TISK_SPACING_STR "Spacing:" +#define MSG_TISK_LEFT_MARGIN_STR "Left Margin:" +#define MSG_TISK_RIGHT_MARGIN_STR "Right Margin:" +#define MSG_TISK_LINE_PER_PAGE_STR "Lines per Page:" +#define MSG_TISK_DENSITY_STR "Density:" +#define MSG_TISK_ASPECT_STR "Aspect:" +#define MSG_TISK_SHADE_STR "Shade:" +#define MSG_TISK_IMAGE_STR "Image:" +#define MSG_TISK_TRESHOLD_STR "Threshold:" +#define MSG_TISK_DITHERING_STR "Dithering:" +#define MSG_TISK_DIMENSION_STR "Dimensions:" +#define MSG_TISK_PAPER_OFFSET_STR "Offset (" +#define MSG_TISK_CENTER_IMAGE_STR "Center Image:" +#define MSG_TISK_ANTIALIAS_STR "AntiAlias:" +#define MSG_TISK_INTEGER_SCALING_STR "Integer Scaling:" +#define MSG_TISK_FANFOLD_STR "Fanfold" +#define MSG_TISK_SINGLE_STR "Single" +#define MSG_TISK_DRAFT_STR "Draft (72 dpi)" +#define MSG_TISK_LETTER_STR "Letter (240 dpi)" +#define MSG_TISK_PORTRAIT_STR "Portrait" +#define MSG_TISK_LANDSCAPE_STR "Landscape" +#define MSG_TISK_BW_STR "Black & White" +#define MSG_TISK_GRAY_STR "Greyscape" +#define MSG_TISK_COLOR_STR "Color" +#define MSG_TISK_GRAY2_STR "Greyscape 2" +#define MSG_TISK_POSITIVE_STR "Positive" +#define MSG_TISK_NEGATIVE_STR "Negative" +#define MSG_TISK_IGNORE_STR "Ignore" +#define MSG_TISK_BOUNDED_STR "Bounded" +#define MSG_TISK_ABSOLUTE_STR "Absolute" +#define MSG_TISK_PIXEL_STR "Pixel" +#define MSG_TISK_MULTIPLY_STR "Multiply" +#define MSG_TISK_ORDERED_STR "Ordered" +#define MSG_TISK_HALFTONE_STR "Halftone" +#define MSG_TISK_FLOYDSTEINBERG_STR "Floyd-Steinberg" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_WINTITLE,(STRPTR)MSG_WINTITLE_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_PRINTER_DRIVER,(STRPTR)MSG_PRINTER_DRIVER_STR}, + {MSG_PRINTER_SETTINGS,(STRPTR)MSG_PRINTER_SETTINGS_STR}, + {MSG_PRINTER_SELECT_DRIVER,(STRPTR)MSG_PRINTER_SELECT_DRIVER_STR}, + {MSG_PRINTER_NAME,(STRPTR)MSG_PRINTER_NAME_STR}, + {MSG_PRINTER_UNIT,(STRPTR)MSG_PRINTER_UNIT_STR}, + {MSG_PRINTER_PS_UNIT,(STRPTR)MSG_PRINTER_PS_UNIT_STR}, + {MSG_PRINTER_CUSTOM_DEVICE,(STRPTR)MSG_PRINTER_CUSTOM_DEVICE_STR}, + {MSG_PRINTER_DEVICE_UNIT,(STRPTR)MSG_PRINTER_DEVICE_UNIT_STR}, + {MSG_PRINTER_PARALLEL,(STRPTR)MSG_PRINTER_PARALLEL_STR}, + {MSG_PRINTER_SERIAL,(STRPTR)MSG_PRINTER_SERIAL_STR}, + {MSG_PRINTER_TO_FILE,(STRPTR)MSG_PRINTER_TO_FILE_STR}, + {MSG_PRINTER_USB,(STRPTR)MSG_PRINTER_USB_STR}, + {MSG_TISK_PAPER_TYPE,(STRPTR)MSG_TISK_PAPER_TYPE_STR}, + {MSG_TISK_PAPER_SIZE,(STRPTR)MSG_TISK_PAPER_SIZE_STR}, + {MSG_TISK_QUALITY,(STRPTR)MSG_TISK_QUALITY_STR}, + {MSG_TISK_PITCH,(STRPTR)MSG_TISK_PITCH_STR}, + {MSG_TISK_SPACING,(STRPTR)MSG_TISK_SPACING_STR}, + {MSG_TISK_LEFT_MARGIN,(STRPTR)MSG_TISK_LEFT_MARGIN_STR}, + {MSG_TISK_RIGHT_MARGIN,(STRPTR)MSG_TISK_RIGHT_MARGIN_STR}, + {MSG_TISK_LINE_PER_PAGE,(STRPTR)MSG_TISK_LINE_PER_PAGE_STR}, + {MSG_TISK_DENSITY,(STRPTR)MSG_TISK_DENSITY_STR}, + {MSG_TISK_ASPECT,(STRPTR)MSG_TISK_ASPECT_STR}, + {MSG_TISK_SHADE,(STRPTR)MSG_TISK_SHADE_STR}, + {MSG_TISK_IMAGE,(STRPTR)MSG_TISK_IMAGE_STR}, + {MSG_TISK_TRESHOLD,(STRPTR)MSG_TISK_TRESHOLD_STR}, + {MSG_TISK_DITHERING,(STRPTR)MSG_TISK_DITHERING_STR}, + {MSG_TISK_DIMENSION,(STRPTR)MSG_TISK_DIMENSION_STR}, + {MSG_TISK_PAPER_OFFSET,(STRPTR)MSG_TISK_PAPER_OFFSET_STR}, + {MSG_TISK_CENTER_IMAGE,(STRPTR)MSG_TISK_CENTER_IMAGE_STR}, + {MSG_TISK_ANTIALIAS,(STRPTR)MSG_TISK_ANTIALIAS_STR}, + {MSG_TISK_INTEGER_SCALING,(STRPTR)MSG_TISK_INTEGER_SCALING_STR}, + {MSG_TISK_FANFOLD,(STRPTR)MSG_TISK_FANFOLD_STR}, + {MSG_TISK_SINGLE,(STRPTR)MSG_TISK_SINGLE_STR}, + {MSG_TISK_DRAFT,(STRPTR)MSG_TISK_DRAFT_STR}, + {MSG_TISK_LETTER,(STRPTR)MSG_TISK_LETTER_STR}, + {MSG_TISK_PORTRAIT,(STRPTR)MSG_TISK_PORTRAIT_STR}, + {MSG_TISK_LANDSCAPE,(STRPTR)MSG_TISK_LANDSCAPE_STR}, + {MSG_TISK_BW,(STRPTR)MSG_TISK_BW_STR}, + {MSG_TISK_GRAY,(STRPTR)MSG_TISK_GRAY_STR}, + {MSG_TISK_COLOR,(STRPTR)MSG_TISK_COLOR_STR}, + {MSG_TISK_GRAY2,(STRPTR)MSG_TISK_GRAY2_STR}, + {MSG_TISK_POSITIVE,(STRPTR)MSG_TISK_POSITIVE_STR}, + {MSG_TISK_NEGATIVE,(STRPTR)MSG_TISK_NEGATIVE_STR}, + {MSG_TISK_IGNORE,(STRPTR)MSG_TISK_IGNORE_STR}, + {MSG_TISK_BOUNDED,(STRPTR)MSG_TISK_BOUNDED_STR}, + {MSG_TISK_ABSOLUTE,(STRPTR)MSG_TISK_ABSOLUTE_STR}, + {MSG_TISK_PIXEL,(STRPTR)MSG_TISK_PIXEL_STR}, + {MSG_TISK_MULTIPLY,(STRPTR)MSG_TISK_MULTIPLY_STR}, + {MSG_TISK_ORDERED,(STRPTR)MSG_TISK_ORDERED_STR}, + {MSG_TISK_HALFTONE,(STRPTR)MSG_TISK_HALFTONE_STR}, + {MSG_TISK_FLOYDSTEINBERG,(STRPTR)MSG_TISK_FLOYDSTEINBERG_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* PRINTER_STRINGS_H */ diff --git a/workbench/system/find/strings.h b/workbench/system/find/strings.h new file mode 100644 index 00000000000..74319405aaf --- /dev/null +++ b/workbench/system/find/strings.h @@ -0,0 +1,169 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/system/find/catalogs/find.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef FIND_STRINGS_H +#define FIND_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_APP_TITLE 0 +#define MSG_APP_DESCRIPTION 1 +#define MSG_APP_COPYRIGHT 2 +#define MSG_WI_TITLE 3 +#define MSG_OK 4 +#define MSG_LST_FULLPATH 5 +#define MSG_LST_SIZE 6 +#define MSG_LST_ATTRIBUTES 7 +#define MSG_LST_DATE 8 +#define MSG_LST_TIME 9 +#define MSG_LST_COMMENT 10 +#define MSG_LBL_PATH 11 +#define MSG_LBL_PATTERN 12 +#define MSG_LBL_CONTENTS 13 +#define MSG_BTN_START 14 +#define MSG_BTN_STOP 15 +#define MSG_BTN_OPEN 16 +#define MSG_BTN_VIEW 17 +#define MSG_BTN_DRAWER 18 +#define MSG_ERR 19 +#define MSG_ERR_NO_APPLICATION 20 +#define MSG_ERR_READARGS 21 +#define MSG_ERR_NO_MEM 22 +#define MSG_ERR_NO_WINDOW 23 +#define MSG_ERR_DOS 24 +#define MSG_ERR_NO_FILE 25 +#define MSG_ERR_NO_DIR 26 +#define MSG_ERR_PATTERN 27 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_APP_TITLE_STR "Find" +#define MSG_APP_DESCRIPTION_STR "File search tool" +#define MSG_APP_COPYRIGHT_STR "Copyright © 2016 The AROS Development Team" +#define MSG_WI_TITLE_STR "Find" +#define MSG_OK_STR "OK" +#define MSG_LST_FULLPATH_STR "Full Path" +#define MSG_LST_SIZE_STR "Size" +#define MSG_LST_ATTRIBUTES_STR "Attributes" +#define MSG_LST_DATE_STR "Date" +#define MSG_LST_TIME_STR "Time" +#define MSG_LST_COMMENT_STR "Comment" +#define MSG_LBL_PATH_STR "Path" +#define MSG_LBL_PATTERN_STR "Pattern" +#define MSG_LBL_CONTENTS_STR "Contents" +#define MSG_BTN_START_STR "Start" +#define MSG_BTN_STOP_STR "Stop" +#define MSG_BTN_OPEN_STR "Open" +#define MSG_BTN_VIEW_STR "View" +#define MSG_BTN_DRAWER_STR "Drawer" +#define MSG_ERR_STR "Error" +#define MSG_ERR_NO_APPLICATION_STR "Can't create application." +#define MSG_ERR_READARGS_STR "Can't read commandline arguments." +#define MSG_ERR_NO_MEM_STR "Error:\nCan't allocate memory." +#define MSG_ERR_NO_WINDOW_STR "Error:\nCan't open window." +#define MSG_ERR_DOS_STR "DOS Error:\n%s" +#define MSG_ERR_NO_FILE_STR "Error:\nCan't open file\n\"%s\"." +#define MSG_ERR_NO_DIR_STR "Error:\nCan't open directory\n\"%s\"." +#define MSG_ERR_PATTERN_STR "Error:\nCan't parse pattern." + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_APP_TITLE,(STRPTR)MSG_APP_TITLE_STR}, + {MSG_APP_DESCRIPTION,(STRPTR)MSG_APP_DESCRIPTION_STR}, + {MSG_APP_COPYRIGHT,(STRPTR)MSG_APP_COPYRIGHT_STR}, + {MSG_WI_TITLE,(STRPTR)MSG_WI_TITLE_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_LST_FULLPATH,(STRPTR)MSG_LST_FULLPATH_STR}, + {MSG_LST_SIZE,(STRPTR)MSG_LST_SIZE_STR}, + {MSG_LST_ATTRIBUTES,(STRPTR)MSG_LST_ATTRIBUTES_STR}, + {MSG_LST_DATE,(STRPTR)MSG_LST_DATE_STR}, + {MSG_LST_TIME,(STRPTR)MSG_LST_TIME_STR}, + {MSG_LST_COMMENT,(STRPTR)MSG_LST_COMMENT_STR}, + {MSG_LBL_PATH,(STRPTR)MSG_LBL_PATH_STR}, + {MSG_LBL_PATTERN,(STRPTR)MSG_LBL_PATTERN_STR}, + {MSG_LBL_CONTENTS,(STRPTR)MSG_LBL_CONTENTS_STR}, + {MSG_BTN_START,(STRPTR)MSG_BTN_START_STR}, + {MSG_BTN_STOP,(STRPTR)MSG_BTN_STOP_STR}, + {MSG_BTN_OPEN,(STRPTR)MSG_BTN_OPEN_STR}, + {MSG_BTN_VIEW,(STRPTR)MSG_BTN_VIEW_STR}, + {MSG_BTN_DRAWER,(STRPTR)MSG_BTN_DRAWER_STR}, + {MSG_ERR,(STRPTR)MSG_ERR_STR}, + {MSG_ERR_NO_APPLICATION,(STRPTR)MSG_ERR_NO_APPLICATION_STR}, + {MSG_ERR_READARGS,(STRPTR)MSG_ERR_READARGS_STR}, + {MSG_ERR_NO_MEM,(STRPTR)MSG_ERR_NO_MEM_STR}, + {MSG_ERR_NO_WINDOW,(STRPTR)MSG_ERR_NO_WINDOW_STR}, + {MSG_ERR_DOS,(STRPTR)MSG_ERR_DOS_STR}, + {MSG_ERR_NO_FILE,(STRPTR)MSG_ERR_NO_FILE_STR}, + {MSG_ERR_NO_DIR,(STRPTR)MSG_ERR_NO_DIR_STR}, + {MSG_ERR_PATTERN,(STRPTR)MSG_ERR_PATTERN_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* FIND_STRINGS_H */ diff --git a/workbench/tools/BoingIconBar/strings.h b/workbench/tools/BoingIconBar/strings.h new file mode 100644 index 00000000000..28a77edfd13 --- /dev/null +++ b/workbench/tools/BoingIconBar/strings.h @@ -0,0 +1,100 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/tools/BoingIconBar/catalogs/boingiconbar.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef BOINGICONBAR_STRINGS_H +#define BOINGICONBAR_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_CX_NAME 0 +#define MSG_CX_TITLE 1 +#define MSG_CX_DESC 2 +#define MSG_MENU_SETTINGS 3 +#define MSG_MENU_QUIT 4 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_CX_NAME_STR "BoingIconBar" +#define MSG_CX_TITLE_STR "Icon Toolbar" +#define MSG_CX_DESC_STR "Start Programs from Toolbar" +#define MSG_MENU_SETTINGS_STR "Settings" +#define MSG_MENU_QUIT_STR "Quit" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_CX_NAME,(STRPTR)MSG_CX_NAME_STR}, + {MSG_CX_TITLE,(STRPTR)MSG_CX_TITLE_STR}, + {MSG_CX_DESC,(STRPTR)MSG_CX_DESC_STR}, + {MSG_MENU_SETTINGS,(STRPTR)MSG_MENU_SETTINGS_STR}, + {MSG_MENU_QUIT,(STRPTR)MSG_MENU_QUIT_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* BOINGICONBAR_STRINGS_H */ diff --git a/workbench/tools/InstallAROS/strings.h b/workbench/tools/InstallAROS/strings.h new file mode 100644 index 00000000000..05291f3eb13 --- /dev/null +++ b/workbench/tools/InstallAROS/strings.h @@ -0,0 +1,355 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/tools/InstallAROS/catalogs/installaros.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef INSTALLAROS_STRINGS_H +#define INSTALLAROS_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_TITLE 0 +#define MSG_DESCRIPTION 1 +#define MSG_WELCOME 2 +#define MSG_INSTALLOPTIONS 3 +#define MSG_DESTOPTIONS 4 +#define MSG_ACCEPT 5 +#define MSG_DRIVE 6 +#define MSG_TYPE 7 +#define MSG_DEVICE 8 +#define MSG_UNIT 9 +#define MSG_NAME 10 +#define MSG_FILESYSTEM 11 +#define MSG_SIZE 12 +#define MSG_MENUMODE 13 +#define MSG_CREATE 14 +#define MSG_SPECIFYSIZE 15 +#define MSG_DESTVOLUME 16 +#define MSG_WORKVOLUME 17 +#define MSG_CHOOSELANG 18 +#define MSG_INSTALLCORE 19 +#define MSG_INSTALLEXTRA 20 +#define MSG_INSTALLDEVEL 21 +#define MSG_INSTALLBOOT 22 +#define MSG_FORMATPART 23 +#define MSG_USEWORK 24 +#define MSG_USEWORKFOR 25 +#define MSG_BEGINWITHPARTITION 26 +#define MSG_BEGINWITHOUTPARTITION 27 +#define MSG_PARTITIONOPTIONS 28 +#define MSG_DESTPARTITION 29 +#define MSG_WORKPARTITION 30 +#define MSG_USEFREE 31 +#define MSG_WIPEDISK 32 +#define MSG_USEEXISTING 33 +#define MSG_PARTITIONTOOBIG 34 +#define MSG_GRUBOPTIONS 35 +#define MSG_GRUBDRIVE 36 +#define MSG_GRUBGOPTIONS 37 +#define MSG_GRUBGRUB 38 +#define MSG_NOGRUBDEVICE 39 +#define MSG_PARTITIONING 40 +#define MSG_FORMATTING 41 +#define MSG_INSTALL 42 +#define MSG_COPYCORE 43 +#define MSG_COPYEXTRA 44 +#define MSG_COPYDEVEL 45 +#define MSG_COPYBOOT 46 +#define MSG_BOOTLOADER 47 +#define MSG_POSTINSTALL 48 +#define MSG_POSTINSTALL2 49 +#define MSG_DONEREBOOT 50 +#define MSG_DONEUSB 51 +#define MSG_INSTALLING 52 +#define MSG_INSTALLINGBOOT 53 +#define MSG_DONE 54 +#define MSG_CANCELOK 55 +#define MSG_CANCELDANGER 56 +#define MSG_BACK 57 +#define MSG_PROCEED 58 +#define MSG_NOTALLFILESCOPIED 59 +#define MSG_PARTITIONINGFAILED 60 +#define MSG_GRUBNONFFSWARNING 61 +#define MSG_CANCELINSTALL 62 +#define MSG_CONTINUECANCELINST 63 +#define MSG_CONTINUECANCELPART 64 +#define MSG_CONTINUEQUIT 65 +#define MSG_EXISTSRETRY 66 +#define MSG_RETRY 67 +#define MSG_SCANRETRY 68 +#define MSG_FINDRETRY 69 +#define MSG_COULDNTOPEN 70 +#define MSG_COULDNTWRITE 71 +#define MSG_DISKFULL 72 +#define MSG_TEXT 73 +#define MSG_GFX 74 +#define MSG_YES 75 +#define MSG_YESALWAYS 76 +#define MSG_NO 77 +#define MSG_SKIP 78 +#define MSG_OK 79 +#define MSG_CANCEL 80 +#define MSG_CANCEL2 81 +#define MSG_QUIT 82 +#define MSG_QUIT2 83 +#define MSG_ERROR 84 +#define MSG_WARNING 85 +#define MSG_REBOOT 86 +#define MSG_IOERROR 87 +#define MSG_NOTFILESYSTEM 88 +#define MSG_NOTDEVICE 89 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_TITLE_STR "AROS Installer" +#define MSG_DESCRIPTION_STR "Installs AROS on to a Drive." +#define MSG_WELCOME_STR "\033b\nWelcome to the AROS Research OS installer.\n\n\033nThis program allows you to install AROS\non your computer's hard disk or an attached USB drive.\n\nPlease be aware that the stability of this software\ncannot be guaranteed.\nIt is possible that \033bloss of data\033n may occur\non any drive in your system, including those\nused by other operating systems.\n" +#define MSG_INSTALLOPTIONS_STR "\nPlease choose your installation options.\n\n" +#define MSG_DESTOPTIONS_STR "\nPlease choose where to install AROS.\n\nIf you are unsure, then use the defaults" +#define MSG_ACCEPT_STR "Accept License Agreement?" +#define MSG_DRIVE_STR "\033bDrive:\033n" +#define MSG_TYPE_STR "Type:" +#define MSG_DEVICE_STR "Device:" +#define MSG_UNIT_STR "Unit:" +#define MSG_NAME_STR "Name:" +#define MSG_FILESYSTEM_STR "Filesystem:" +#define MSG_SIZE_STR "Size:" +#define MSG_MENUMODE_STR "Menu Mode:" +#define MSG_CREATE_STR "Create" +#define MSG_SPECIFYSIZE_STR "Specify Size" +#define MSG_DESTVOLUME_STR "Destination Partition" +#define MSG_WORKVOLUME_STR "Work Partition" +#define MSG_CHOOSELANG_STR "Choose Language Options" +#define MSG_INSTALLCORE_STR "Install AROS Core System" +#define MSG_INSTALLEXTRA_STR "Install Extra Software" +#define MSG_INSTALLDEVEL_STR "Install Debugging tools and Developer Software" +#define MSG_INSTALLBOOT_STR "Install Bootloader" +#define MSG_FORMATPART_STR "Format Partition" +#define MSG_USEWORK_STR "Use 'Work' Partition" +#define MSG_USEWORKFOR_STR "Use 'Work' Partition for Extras and Developer Files" +#define MSG_BEGINWITHPARTITION_STR "OK, we are ready to begin.\n\nSince you've chosen to format at least one partition,\nyou will no longer be able to undo changes\nafter this point.\n\nSelect Proceed to begin installation." +#define MSG_BEGINWITHOUTPARTITION_STR "OK, we are ready to begin...\n\nWe have collected enough information\nto begin installation on this computer.\n\n\nSelect Proceed to begin installation." +#define MSG_PARTITIONOPTIONS_STR "We will now create AROS partitions on the destination drive.\n\nPlease select how you would like to proceed.\n" +#define MSG_DESTPARTITION_STR "\033bSystem Partition:\033n" +#define MSG_WORKPARTITION_STR "\033bWork Partition:\033n" +#define MSG_USEFREE_STR "Only use free space" +#define MSG_WIPEDISK_STR "Wipe disk" +#define MSG_USEEXISTING_STR "Use existing AROS partitions (on any drive)" +#define MSG_PARTITIONTOOBIG_STR "The partition sizes you have requested are too large.\nThe maximum size of an SFS partition is %ld GB (%ld MB),\nwhile the maximum size of an FFS partition is %ld GB (%ld MB).\nPlease reduce the size of the affected partitions.\n" +#define MSG_GRUBOPTIONS_STR "AROS uses the GRUB bootloader.\n\nIn most cases, GRUB's bootblock should\nbe installed on the first drive in your system.\nIf the Installer detects a Microsoft Windows installation,\nit will be included as a choice in GRUB's boot menu.\n" +#define MSG_GRUBDRIVE_STR "Drive to install Bootloader's bootblock on:" +#define MSG_GRUBGOPTIONS_STR "GRUB Settings" +#define MSG_GRUBGRUB_STR "Path to GRUB files:" +#define MSG_NOGRUBDEVICE_STR "Please enter the device name and unit number for\nthe drive GRUB's bootblock should be installed on.\n" +#define MSG_PARTITIONING_STR "Partitioning your drives...\n\n" +#define MSG_FORMATTING_STR "Formatting '%s'..." +#define MSG_INSTALL_STR "Copying files to the destination drive.\n\nThis may take some time...\n" +#define MSG_COPYCORE_STR "Copying Core System files..." +#define MSG_COPYEXTRA_STR "Copying Extra Software..." +#define MSG_COPYDEVEL_STR "Copying Developer Files..." +#define MSG_COPYBOOT_STR "Copying BOOT files..." +#define MSG_BOOTLOADER_STR "Copying the bootloader to your\ndestination drive, and installing...\n" +#define MSG_POSTINSTALL_STR "Running post-install script..." +#define MSG_POSTINSTALL2_STR "Running the external post-install\nscript. Please wait.\n" +#define MSG_DONEREBOOT_STR "AROS partitions have now been created!\nTo continue installation, you must\nreboot AROS, and re-run\nthis installer application\n\nSelect Proceed to finish\n" +#define MSG_DONEUSB_STR "AROS partitions have now been created!\nTo continue installation, you must remove\nand re-attach your USB drive, and re-run\nthis installer application\n\nSelect Proceed to finish\n" +#define MSG_INSTALLING_STR "Installing AROS..." +#define MSG_INSTALLINGBOOT_STR "Installing Bootloader..." +#define MSG_DONE_STR "Congratulations, you now have AROS installed!\n\nTo boot AROS from the destination drive,\nremove the installation media and\nrestart your computer using the\npower switch or reset button.\n\nSelect Proceed to finish\n" +#define MSG_CANCELOK_STR "Are you sure you wish to cancel\nthis installation?\n" +#define MSG_CANCELDANGER_STR "Irreversible changes have been made\nto your system.\n\nCancelling now may leave your PC in an\nunbootable state\n\nAre you sure you wish to cancel\nthis installation?\n" +#define MSG_BACK_STR "<< _Back..." +#define MSG_PROCEED_STR "_Proceed" +#define MSG_NOTALLFILESCOPIED_STR "Not all files in '%s'\nwere copied.\nShould the installation continue?\n" +#define MSG_PARTITIONINGFAILED_STR "Partitioning of disk failed. InstallAROS\nwill now quit." +#define MSG_GRUBNONFFSWARNING_STR "You have selected a filesystem different\nthan FFS-Intl for the system partition. Since\nthis distribution of AROS is compiled with the\noriginal GRUB bootloader, you will not be able to\nboot the system after installation.\n\nShould the partitioning continue?\n" +#define MSG_CANCELINSTALL_STR "Cancel Installation..." +#define MSG_CONTINUECANCELINST_STR "*Continue Install|Cancel Install" +#define MSG_CONTINUECANCELPART_STR "Continue Partitioning|*Cancel Partitionin" +#define MSG_CONTINUEQUIT_STR "Continue|*Quit" +#define MSG_EXISTSRETRY_STR "File Already Exists\nReplace %s?" +#define MSG_RETRY_STR "Retry" +#define MSG_SCANRETRY_STR "Error scanning %s\nRetry?" +#define MSG_FINDRETRY_STR "Could not find %s\nRetry?" +#define MSG_COULDNTOPEN_STR "Couldn't Open %s" +#define MSG_COULDNTWRITE_STR "Couldn't Write to %s" +#define MSG_DISKFULL_STR "Couldn't Write to %s\nDisk Full!" +#define MSG_TEXT_STR "Text" +#define MSG_GFX_STR "Graphics" +#define MSG_YES_STR "Yes" +#define MSG_YESALWAYS_STR "Yes [Always]" +#define MSG_NO_STR "No" +#define MSG_SKIP_STR "Skip" +#define MSG_OK_STR "OK" +#define MSG_CANCEL_STR "Cancel" +#define MSG_CANCEL2_STR "_Cancel" +#define MSG_QUIT_STR "Quit" +#define MSG_QUIT2_STR "QUIT" +#define MSG_ERROR_STR "Error" +#define MSG_WARNING_STR "Warning" +#define MSG_REBOOT_STR "Reboot AROS now" +#define MSG_IOERROR_STR "IO Error has occured" +#define MSG_NOTFILESYSTEM_STR "device '%s' doesn't contain a file system\n" +#define MSG_NOTDEVICE_STR "'%s' doesn't contain a device name\n" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_TITLE,(STRPTR)MSG_TITLE_STR}, + {MSG_DESCRIPTION,(STRPTR)MSG_DESCRIPTION_STR}, + {MSG_WELCOME,(STRPTR)MSG_WELCOME_STR}, + {MSG_INSTALLOPTIONS,(STRPTR)MSG_INSTALLOPTIONS_STR}, + {MSG_DESTOPTIONS,(STRPTR)MSG_DESTOPTIONS_STR}, + {MSG_ACCEPT,(STRPTR)MSG_ACCEPT_STR}, + {MSG_DRIVE,(STRPTR)MSG_DRIVE_STR}, + {MSG_TYPE,(STRPTR)MSG_TYPE_STR}, + {MSG_DEVICE,(STRPTR)MSG_DEVICE_STR}, + {MSG_UNIT,(STRPTR)MSG_UNIT_STR}, + {MSG_NAME,(STRPTR)MSG_NAME_STR}, + {MSG_FILESYSTEM,(STRPTR)MSG_FILESYSTEM_STR}, + {MSG_SIZE,(STRPTR)MSG_SIZE_STR}, + {MSG_MENUMODE,(STRPTR)MSG_MENUMODE_STR}, + {MSG_CREATE,(STRPTR)MSG_CREATE_STR}, + {MSG_SPECIFYSIZE,(STRPTR)MSG_SPECIFYSIZE_STR}, + {MSG_DESTVOLUME,(STRPTR)MSG_DESTVOLUME_STR}, + {MSG_WORKVOLUME,(STRPTR)MSG_WORKVOLUME_STR}, + {MSG_CHOOSELANG,(STRPTR)MSG_CHOOSELANG_STR}, + {MSG_INSTALLCORE,(STRPTR)MSG_INSTALLCORE_STR}, + {MSG_INSTALLEXTRA,(STRPTR)MSG_INSTALLEXTRA_STR}, + {MSG_INSTALLDEVEL,(STRPTR)MSG_INSTALLDEVEL_STR}, + {MSG_INSTALLBOOT,(STRPTR)MSG_INSTALLBOOT_STR}, + {MSG_FORMATPART,(STRPTR)MSG_FORMATPART_STR}, + {MSG_USEWORK,(STRPTR)MSG_USEWORK_STR}, + {MSG_USEWORKFOR,(STRPTR)MSG_USEWORKFOR_STR}, + {MSG_BEGINWITHPARTITION,(STRPTR)MSG_BEGINWITHPARTITION_STR}, + {MSG_BEGINWITHOUTPARTITION,(STRPTR)MSG_BEGINWITHOUTPARTITION_STR}, + {MSG_PARTITIONOPTIONS,(STRPTR)MSG_PARTITIONOPTIONS_STR}, + {MSG_DESTPARTITION,(STRPTR)MSG_DESTPARTITION_STR}, + {MSG_WORKPARTITION,(STRPTR)MSG_WORKPARTITION_STR}, + {MSG_USEFREE,(STRPTR)MSG_USEFREE_STR}, + {MSG_WIPEDISK,(STRPTR)MSG_WIPEDISK_STR}, + {MSG_USEEXISTING,(STRPTR)MSG_USEEXISTING_STR}, + {MSG_PARTITIONTOOBIG,(STRPTR)MSG_PARTITIONTOOBIG_STR}, + {MSG_GRUBOPTIONS,(STRPTR)MSG_GRUBOPTIONS_STR}, + {MSG_GRUBDRIVE,(STRPTR)MSG_GRUBDRIVE_STR}, + {MSG_GRUBGOPTIONS,(STRPTR)MSG_GRUBGOPTIONS_STR}, + {MSG_GRUBGRUB,(STRPTR)MSG_GRUBGRUB_STR}, + {MSG_NOGRUBDEVICE,(STRPTR)MSG_NOGRUBDEVICE_STR}, + {MSG_PARTITIONING,(STRPTR)MSG_PARTITIONING_STR}, + {MSG_FORMATTING,(STRPTR)MSG_FORMATTING_STR}, + {MSG_INSTALL,(STRPTR)MSG_INSTALL_STR}, + {MSG_COPYCORE,(STRPTR)MSG_COPYCORE_STR}, + {MSG_COPYEXTRA,(STRPTR)MSG_COPYEXTRA_STR}, + {MSG_COPYDEVEL,(STRPTR)MSG_COPYDEVEL_STR}, + {MSG_COPYBOOT,(STRPTR)MSG_COPYBOOT_STR}, + {MSG_BOOTLOADER,(STRPTR)MSG_BOOTLOADER_STR}, + {MSG_POSTINSTALL,(STRPTR)MSG_POSTINSTALL_STR}, + {MSG_POSTINSTALL2,(STRPTR)MSG_POSTINSTALL2_STR}, + {MSG_DONEREBOOT,(STRPTR)MSG_DONEREBOOT_STR}, + {MSG_DONEUSB,(STRPTR)MSG_DONEUSB_STR}, + {MSG_INSTALLING,(STRPTR)MSG_INSTALLING_STR}, + {MSG_INSTALLINGBOOT,(STRPTR)MSG_INSTALLINGBOOT_STR}, + {MSG_DONE,(STRPTR)MSG_DONE_STR}, + {MSG_CANCELOK,(STRPTR)MSG_CANCELOK_STR}, + {MSG_CANCELDANGER,(STRPTR)MSG_CANCELDANGER_STR}, + {MSG_BACK,(STRPTR)MSG_BACK_STR}, + {MSG_PROCEED,(STRPTR)MSG_PROCEED_STR}, + {MSG_NOTALLFILESCOPIED,(STRPTR)MSG_NOTALLFILESCOPIED_STR}, + {MSG_PARTITIONINGFAILED,(STRPTR)MSG_PARTITIONINGFAILED_STR}, + {MSG_GRUBNONFFSWARNING,(STRPTR)MSG_GRUBNONFFSWARNING_STR}, + {MSG_CANCELINSTALL,(STRPTR)MSG_CANCELINSTALL_STR}, + {MSG_CONTINUECANCELINST,(STRPTR)MSG_CONTINUECANCELINST_STR}, + {MSG_CONTINUECANCELPART,(STRPTR)MSG_CONTINUECANCELPART_STR}, + {MSG_CONTINUEQUIT,(STRPTR)MSG_CONTINUEQUIT_STR}, + {MSG_EXISTSRETRY,(STRPTR)MSG_EXISTSRETRY_STR}, + {MSG_RETRY,(STRPTR)MSG_RETRY_STR}, + {MSG_SCANRETRY,(STRPTR)MSG_SCANRETRY_STR}, + {MSG_FINDRETRY,(STRPTR)MSG_FINDRETRY_STR}, + {MSG_COULDNTOPEN,(STRPTR)MSG_COULDNTOPEN_STR}, + {MSG_COULDNTWRITE,(STRPTR)MSG_COULDNTWRITE_STR}, + {MSG_DISKFULL,(STRPTR)MSG_DISKFULL_STR}, + {MSG_TEXT,(STRPTR)MSG_TEXT_STR}, + {MSG_GFX,(STRPTR)MSG_GFX_STR}, + {MSG_YES,(STRPTR)MSG_YES_STR}, + {MSG_YESALWAYS,(STRPTR)MSG_YESALWAYS_STR}, + {MSG_NO,(STRPTR)MSG_NO_STR}, + {MSG_SKIP,(STRPTR)MSG_SKIP_STR}, + {MSG_OK,(STRPTR)MSG_OK_STR}, + {MSG_CANCEL,(STRPTR)MSG_CANCEL_STR}, + {MSG_CANCEL2,(STRPTR)MSG_CANCEL2_STR}, + {MSG_QUIT,(STRPTR)MSG_QUIT_STR}, + {MSG_QUIT2,(STRPTR)MSG_QUIT2_STR}, + {MSG_ERROR,(STRPTR)MSG_ERROR_STR}, + {MSG_WARNING,(STRPTR)MSG_WARNING_STR}, + {MSG_REBOOT,(STRPTR)MSG_REBOOT_STR}, + {MSG_IOERROR,(STRPTR)MSG_IOERROR_STR}, + {MSG_NOTFILESYSTEM,(STRPTR)MSG_NOTFILESYSTEM_STR}, + {MSG_NOTDEVICE,(STRPTR)MSG_NOTDEVICE_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* INSTALLAROS_STRINGS_H */ diff --git a/workbench/tools/SysExplorer/strings.h b/workbench/tools/SysExplorer/strings.h new file mode 100644 index 00000000000..c912076c4b2 --- /dev/null +++ b/workbench/tools/SysExplorer/strings.h @@ -0,0 +1,214 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/tools/SysExplorer/catalogs/sysexplorer.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef SYSEXPLORER_STRINGS_H +#define SYSEXPLORER_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_TITLE 0 +#define MSG_WINTITLE 1 +#define MSG_DESCRIPTION 2 +#define MSG_MENU_PROJECT 3 +#define MSG_MENU_PROPERTIES 4 +#define MSG_MENU_EXPANDALL 5 +#define MSG_MENU_COLLAPSEALL 6 +#define MSG_MENU_QUIT 7 +#define MSG_HIDD_TREE 8 +#define MSG_PROPERTIES 9 +#define MSG_LABEL_DRIVER 10 +#define MSG_LABEL_HW_DESCRIPTION 11 +#define MSG_LABEL_VENDOR 12 +#define MSG_SYSTEM_PROPERTIES 13 +#define MSG_VERSION 14 +#define MSG_PROCESSORS 15 +#define MSG_HPET 16 +#define MSG_RAM 17 +#define MSG_BOOTLOADER 18 +#define MSG_ARGUMENTS 19 +#define MSG_AVAILABLE 20 +#define MSG_GENERAL 21 +#define MSG_NAME 22 +#define MSG_HARDWARE_NAME 23 +#define MSG_PRODUCT_ID 24 +#define MSG_PRODUCER_NAME 25 +#define MSG_PRODUCER_ID 26 +#define MSG_DEVICE_PROPERTIES 27 +#define MSG_ATA_PROPERTIES 28 +#define MSG_ATA 29 +#define MSG_USE_IOALT 30 +#define MSG_USE_32BIT 31 +#define MSG_USE_DMA 32 +#define MSG_USE_80WIRE 33 +#define MSG_ATA_UNIT_PROPERTIES 34 +#define MSG_UNIT_NUMBER 35 +#define MSG_MODEL 36 +#define MSG_REVISION 37 +#define MSG_SERIAL 38 +#define MSG_TRANSFER_MODES 39 +#define MSG_MULTISECTOR 40 +#define MSG_REMOVABLE 41 +#define MSG_CONFIG_MODES 42 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_TITLE_STR "System Explorer" +#define MSG_WINTITLE_STR "System Explorer" +#define MSG_DESCRIPTION_STR "System and hardware information tool" +#define MSG_MENU_PROJECT_STR "Project" +#define MSG_MENU_PROPERTIES_STR "Properties" +#define MSG_MENU_EXPANDALL_STR "Expand All" +#define MSG_MENU_COLLAPSEALL_STR "Collapse All" +#define MSG_MENU_QUIT_STR "Quit" +#define MSG_HIDD_TREE_STR "HIDD Tree" +#define MSG_PROPERTIES_STR "Properties" +#define MSG_LABEL_DRIVER_STR "Driver instance name" +#define MSG_LABEL_HW_DESCRIPTION_STR "Hardware description" +#define MSG_LABEL_VENDOR_STR "Vendor information" +#define MSG_SYSTEM_PROPERTIES_STR "System properties" +#define MSG_VERSION_STR "Version" +#define MSG_PROCESSORS_STR "Processors" +#define MSG_HPET_STR "HPET" +#define MSG_RAM_STR "Memory" +#define MSG_BOOTLOADER_STR "Boot loader" +#define MSG_ARGUMENTS_STR "Boot Arguments" +#define MSG_AVAILABLE_STR "Available for use" +#define MSG_GENERAL_STR "General" +#define MSG_NAME_STR "Name" +#define MSG_HARDWARE_NAME_STR "Hardware Name" +#define MSG_PRODUCT_ID_STR "Product ID" +#define MSG_PRODUCER_NAME_STR "Vendor Name" +#define MSG_PRODUCER_ID_STR "Vendor ID" +#define MSG_DEVICE_PROPERTIES_STR "Device properties" +#define MSG_ATA_PROPERTIES_STR "IDE bus properties" +#define MSG_ATA_STR "IDE" +#define MSG_USE_IOALT_STR "Supports alternate registers" +#define MSG_USE_32BIT_STR "Supports 32-bit PIO" +#define MSG_USE_DMA_STR "Supports DMA" +#define MSG_USE_80WIRE_STR "80-wire cable" +#define MSG_ATA_UNIT_PROPERTIES_STR "IDE device properties" +#define MSG_UNIT_NUMBER_STR "Unit number" +#define MSG_MODEL_STR "Model" +#define MSG_REVISION_STR "Revision" +#define MSG_SERIAL_STR "Serial" +#define MSG_TRANSFER_MODES_STR "Supported modes" +#define MSG_MULTISECTOR_STR "Multisector limit" +#define MSG_REMOVABLE_STR "Removable" +#define MSG_CONFIG_MODES_STR "Configured modes" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_TITLE,(STRPTR)MSG_TITLE_STR}, + {MSG_WINTITLE,(STRPTR)MSG_WINTITLE_STR}, + {MSG_DESCRIPTION,(STRPTR)MSG_DESCRIPTION_STR}, + {MSG_MENU_PROJECT,(STRPTR)MSG_MENU_PROJECT_STR}, + {MSG_MENU_PROPERTIES,(STRPTR)MSG_MENU_PROPERTIES_STR}, + {MSG_MENU_EXPANDALL,(STRPTR)MSG_MENU_EXPANDALL_STR}, + {MSG_MENU_COLLAPSEALL,(STRPTR)MSG_MENU_COLLAPSEALL_STR}, + {MSG_MENU_QUIT,(STRPTR)MSG_MENU_QUIT_STR}, + {MSG_HIDD_TREE,(STRPTR)MSG_HIDD_TREE_STR}, + {MSG_PROPERTIES,(STRPTR)MSG_PROPERTIES_STR}, + {MSG_LABEL_DRIVER,(STRPTR)MSG_LABEL_DRIVER_STR}, + {MSG_LABEL_HW_DESCRIPTION,(STRPTR)MSG_LABEL_HW_DESCRIPTION_STR}, + {MSG_LABEL_VENDOR,(STRPTR)MSG_LABEL_VENDOR_STR}, + {MSG_SYSTEM_PROPERTIES,(STRPTR)MSG_SYSTEM_PROPERTIES_STR}, + {MSG_VERSION,(STRPTR)MSG_VERSION_STR}, + {MSG_PROCESSORS,(STRPTR)MSG_PROCESSORS_STR}, + {MSG_HPET,(STRPTR)MSG_HPET_STR}, + {MSG_RAM,(STRPTR)MSG_RAM_STR}, + {MSG_BOOTLOADER,(STRPTR)MSG_BOOTLOADER_STR}, + {MSG_ARGUMENTS,(STRPTR)MSG_ARGUMENTS_STR}, + {MSG_AVAILABLE,(STRPTR)MSG_AVAILABLE_STR}, + {MSG_GENERAL,(STRPTR)MSG_GENERAL_STR}, + {MSG_NAME,(STRPTR)MSG_NAME_STR}, + {MSG_HARDWARE_NAME,(STRPTR)MSG_HARDWARE_NAME_STR}, + {MSG_PRODUCT_ID,(STRPTR)MSG_PRODUCT_ID_STR}, + {MSG_PRODUCER_NAME,(STRPTR)MSG_PRODUCER_NAME_STR}, + {MSG_PRODUCER_ID,(STRPTR)MSG_PRODUCER_ID_STR}, + {MSG_DEVICE_PROPERTIES,(STRPTR)MSG_DEVICE_PROPERTIES_STR}, + {MSG_ATA_PROPERTIES,(STRPTR)MSG_ATA_PROPERTIES_STR}, + {MSG_ATA,(STRPTR)MSG_ATA_STR}, + {MSG_USE_IOALT,(STRPTR)MSG_USE_IOALT_STR}, + {MSG_USE_32BIT,(STRPTR)MSG_USE_32BIT_STR}, + {MSG_USE_DMA,(STRPTR)MSG_USE_DMA_STR}, + {MSG_USE_80WIRE,(STRPTR)MSG_USE_80WIRE_STR}, + {MSG_ATA_UNIT_PROPERTIES,(STRPTR)MSG_ATA_UNIT_PROPERTIES_STR}, + {MSG_UNIT_NUMBER,(STRPTR)MSG_UNIT_NUMBER_STR}, + {MSG_MODEL,(STRPTR)MSG_MODEL_STR}, + {MSG_REVISION,(STRPTR)MSG_REVISION_STR}, + {MSG_SERIAL,(STRPTR)MSG_SERIAL_STR}, + {MSG_TRANSFER_MODES,(STRPTR)MSG_TRANSFER_MODES_STR}, + {MSG_MULTISECTOR,(STRPTR)MSG_MULTISECTOR_STR}, + {MSG_REMOVABLE,(STRPTR)MSG_REMOVABLE_STR}, + {MSG_CONFIG_MODES,(STRPTR)MSG_CONFIG_MODES_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* SYSEXPLORER_STRINGS_H */ diff --git a/workbench/tools/WiMP/strings.h b/workbench/tools/WiMP/strings.h new file mode 100644 index 00000000000..5f27762e5c6 --- /dev/null +++ b/workbench/tools/WiMP/strings.h @@ -0,0 +1,343 @@ +/**************************************************************** + This file was created automatically by `FlexCat 2.19' + from "/home/willem/ApolloOS/workbench/tools/WiMP/catalogs/WiMP.cd". + + Do NOT edit by hand! +****************************************************************/ + +#ifndef WIMP_STRINGS_H +#define WIMP_STRINGS_H + + +#ifndef EXEC_TYPES_H +#include +#endif + + +#ifdef CATCOMP_ARRAY +#ifndef CATCOMPARRAY +#define CATCOMPARRAY CatCompArray +#endif +#undef CATCOMP_NUMBERS +#undef CATCOMP_STRINGS +#define CATCOMP_NUMBERS +#define CATCOMP_STRINGS +#endif + +#ifdef CATCOMP_BLOCK +#undef CATCOMP_STRINGS +#define CATCOMP_STRINGS +#endif + +/***************************************************************/ + +#ifdef CATCOMP_NUMBERS + +#define MSG_APP_NAME 0 +#define MSG_APP_TITLE 1 +#define MSG_APP_ABOUT 2 +#define MSG_APP_COPYRIGHT 3 +#define MSG_APP_AUTOR 4 +#define MSG_APP_BASE 5 +#define MSG_WINDOW_TITLE 6 +#define MSG_INFO_TITLE 7 +#define MSG_CLOSE_SCREEN 8 +#define MSG_CLOSE_WINDOW 9 +#define MSG_YES_NO 10 +#define MSG_CONTINUE 11 +#define MSG_BTN_KILL 12 +#define MSG_BTN_FRONT 13 +#define MSG_BTN_BACK 14 +#define MSG_BTN_MOVE 15 +#define MSG_BTN_ACTIVATE 16 +#define MSG_BTN_ZIP 17 +#define MSG_BTN_HIDE 18 +#define MSG_BTN_SHOW 19 +#define MSG_BTN_UPDATE_LIST 20 +#define MSG_BTN_RESCUE_ALL 21 +#define MSG_BTN_SHOW_ALL 22 +#define MSG_BTN_RETHING 23 +#define MSG_BTN_ABOUT 24 +#define MSG_SCREEN_WINDOW_LIST 25 +#define MSG_MENU_PROJECT 26 +#define MSG_MENU_ABOUT 27 +#define MSG_MENU_QUIT 28 +#define MSG_MENU_WIN_LIST 29 +#define MSG_MENU_UPDATE_LIST 30 +#define MSG_MENU_KILL 31 +#define MSG_MENU_TO_FRONT 32 +#define MSG_MENU_TO_BACK 33 +#define MSG_MENU_TO_ORIGIN 34 +#define MSG_MENU_ACTIVATE 35 +#define MSG_MENU_ZIP 36 +#define MSG_MENU_HIDE 37 +#define MSG_MENU_SHOW 38 +#define MSG_MENU_INFO 39 +#define MSG_MENU_GENERIC 40 +#define MSG_MENU_RESCUE_ALL 41 +#define MSG_MENU_SHOW_ALL 42 +#define MSG_MENU_RETHINGDISPLAY 43 +#define MSG_ARRAY_WINDOW 44 +#define MSG_ARRAY_SCREEN 45 +#define MSG_ARRAY_0_TYPE 46 +#define MSG_ARRAY_1_ADDRESS 47 +#define MSG_ARRAY_2_SIZE 48 +#define MSG_ARRAY_3_POSITION 49 +#define MSG_ARRAY_4_STATUS 50 +#define MSG_ARRAY_5_TITLE 51 +#define MSG_COL_SCREEN 52 +#define MSG_COL_SCR_ADDRESS 53 +#define MSG_COL_SCR_LEFTEDGE 54 +#define MSG_COL_SCR_TOPEDGE 55 +#define MSG_COL_SCR_WIDTH 56 +#define MSG_COL_SCR_HEIGHT 57 +#define MSG_COL_SCR_FLAGS 58 +#define MSG_COL_SCR_TITLE 59 +#define MSG_COL_SCR_DEFAULTIT 60 +#define MSG_COL_SCR_FRSTWIN 61 +#define MSG_COL_WIDOW 62 +#define MSG_COL_WIN_ADDRESS 63 +#define MSG_COL_WIN_NEXTWIN 64 +#define MSG_COL_WIN_LEFTEDGE 65 +#define MSG_COL_WIN_TOPEDGE 66 +#define MSG_COL_WIN_WIDTH 67 +#define MSG_COL_WIN_HEIGHT 68 +#define MSG_COL_WIN_MINWIDTH 69 +#define MSG_COL_WIN_MINHEIGHT 70 +#define MSG_COL_WIN_MAXWIDTH 71 +#define MSG_COL_WIN_MAXHEIGHT 72 +#define MSG_COL_WIN_FLAGS 73 +#define MSG_COL_WIN_IDCMPFLAGS 74 +#define MSG_COL_WIN_TITLE 75 +#define MSG_COL_WIN_REQCOUNT 76 +#define MSG_COL_WIN_WSCREEN 77 +#define MSG_COL_WIN_BORDERLEFT 78 +#define MSG_COL_WIN_BORDERTOP 79 +#define MSG_COL_WIN_BORDERRIGHT 80 +#define MSG_COL_WIN_BORDERBOTTOM 81 +#define MSG_COL_WIN_PARENTWIN 82 +#define MSG_COL_WIN_FIRSTCHILD 83 +#define MSG_COL_WIN_PARENT 84 +#define MSG_COL_WIN_DESCENDANT 85 + +#endif /* CATCOMP_NUMBERS */ + +/***************************************************************/ + +#ifdef CATCOMP_STRINGS + +#define MSG_APP_NAME_STR "WiMP" +#define MSG_APP_TITLE_STR "Window Manipulator" +#define MSG_APP_ABOUT_STR "WiMP - The Window Manipulation Program\n\nCopyright © 2000-2019 by The AROS Development Team" +#define MSG_APP_COPYRIGHT_STR "Copyright © 1995-2019, The AROS Development Team" +#define MSG_APP_AUTOR_STR "The AROS Development Team" +#define MSG_APP_BASE_STR "WIMP" +#define MSG_WINDOW_TITLE_STR "WiMP - The Window Manipulation Program" +#define MSG_INFO_TITLE_STR "WiMP - InfoWindow" +#define MSG_CLOSE_SCREEN_STR "Do you really want to Close the selected Screen?" +#define MSG_CLOSE_WINDOW_STR "Do you really want to Close the selected Window?" +#define MSG_YES_NO_STR "Yes.|No!" +#define MSG_CONTINUE_STR "Continue" +#define MSG_BTN_KILL_STR "\033iKill" +#define MSG_BTN_FRONT_STR "To _Front" +#define MSG_BTN_BACK_STR "To _Back" +#define MSG_BTN_MOVE_STR "Move to _Origin" +#define MSG_BTN_ACTIVATE_STR "_Activate" +#define MSG_BTN_ZIP_STR "_Zip" +#define MSG_BTN_HIDE_STR "_Hide" +#define MSG_BTN_SHOW_STR "_Show" +#define MSG_BTN_UPDATE_LIST_STR "_Update List" +#define MSG_BTN_RESCUE_ALL_STR "_Rescue all Windows" +#define MSG_BTN_SHOW_ALL_STR "Show all Windows" +#define MSG_BTN_RETHING_STR "Rethink Display" +#define MSG_BTN_ABOUT_STR "About" +#define MSG_SCREEN_WINDOW_LIST_STR "Screen/Window List" +#define MSG_MENU_PROJECT_STR "Project" +#define MSG_MENU_ABOUT_STR "About..." +#define MSG_MENU_QUIT_STR "Quit" +#define MSG_MENU_WIN_LIST_STR "Window List" +#define MSG_MENU_UPDATE_LIST_STR "Update List" +#define MSG_MENU_KILL_STR "Kill" +#define MSG_MENU_TO_FRONT_STR "To Front" +#define MSG_MENU_TO_BACK_STR "To Back" +#define MSG_MENU_TO_ORIGIN_STR "To Origin" +#define MSG_MENU_ACTIVATE_STR "Activate" +#define MSG_MENU_ZIP_STR "Zip" +#define MSG_MENU_HIDE_STR "Hide" +#define MSG_MENU_SHOW_STR "Show" +#define MSG_MENU_INFO_STR "Info" +#define MSG_MENU_GENERIC_STR "Generic" +#define MSG_MENU_RESCUE_ALL_STR "Rescue All" +#define MSG_MENU_SHOW_ALL_STR "Show All" +#define MSG_MENU_RETHINGDISPLAY_STR "RethinkDisplay" +#define MSG_ARRAY_WINDOW_STR " \033bWindow" +#define MSG_ARRAY_SCREEN_STR "\033b\033uScreen" +#define MSG_ARRAY_0_TYPE_STR "Type" +#define MSG_ARRAY_1_ADDRESS_STR "Address" +#define MSG_ARRAY_2_SIZE_STR "Size" +#define MSG_ARRAY_3_POSITION_STR "Position" +#define MSG_ARRAY_4_STATUS_STR "Status" +#define MSG_ARRAY_5_TITLE_STR "Title" +#define MSG_COL_SCREEN_STR "Screen" +#define MSG_COL_SCR_ADDRESS_STR "Address" +#define MSG_COL_SCR_LEFTEDGE_STR "LeftEdge" +#define MSG_COL_SCR_TOPEDGE_STR "TopEdge" +#define MSG_COL_SCR_WIDTH_STR "Width" +#define MSG_COL_SCR_HEIGHT_STR "Height" +#define MSG_COL_SCR_FLAGS_STR "Flags" +#define MSG_COL_SCR_TITLE_STR "Title" +#define MSG_COL_SCR_DEFAULTIT_STR "DefaultTitle" +#define MSG_COL_SCR_FRSTWIN_STR "FirstWindow" +#define MSG_COL_WIDOW_STR "Window" +#define MSG_COL_WIN_ADDRESS_STR "Address" +#define MSG_COL_WIN_NEXTWIN_STR "NextWindow" +#define MSG_COL_WIN_LEFTEDGE_STR "LeftEdge" +#define MSG_COL_WIN_TOPEDGE_STR "TopEdge" +#define MSG_COL_WIN_WIDTH_STR "Width" +#define MSG_COL_WIN_HEIGHT_STR "Height" +#define MSG_COL_WIN_MINWIDTH_STR "MinWidth" +#define MSG_COL_WIN_MINHEIGHT_STR "MinHeight" +#define MSG_COL_WIN_MAXWIDTH_STR "MaxWidth" +#define MSG_COL_WIN_MAXHEIGHT_STR "MaxHeight" +#define MSG_COL_WIN_FLAGS_STR "Flags" +#define MSG_COL_WIN_IDCMPFLAGS_STR "IDCMPFlags" +#define MSG_COL_WIN_TITLE_STR "Title" +#define MSG_COL_WIN_REQCOUNT_STR "ReqCount" +#define MSG_COL_WIN_WSCREEN_STR "WScreen" +#define MSG_COL_WIN_BORDERLEFT_STR "BorderLeft" +#define MSG_COL_WIN_BORDERTOP_STR "BorderTop" +#define MSG_COL_WIN_BORDERRIGHT_STR "BorderRight" +#define MSG_COL_WIN_BORDERBOTTOM_STR "BoderBottom" +#define MSG_COL_WIN_PARENTWIN_STR "Parent Window" +#define MSG_COL_WIN_FIRSTCHILD_STR "First Child" +#define MSG_COL_WIN_PARENT_STR "Parent" +#define MSG_COL_WIN_DESCENDANT_STR "Descendant" + +#endif /* CATCOMP_STRINGS */ + +/***************************************************************/ + +#ifdef CATCOMP_ARRAY + +#ifndef HAVE_CATCOMP_ARRAYTYPE +#define HAVE_CATCOMP_ARRAYTYPE +struct CatCompArrayType +{ + IPTR cca_ID; + STRPTR cca_Str; +}; +#endif + +static const struct CatCompArrayType CATCOMPARRAY[] = +{ + {MSG_APP_NAME,(STRPTR)MSG_APP_NAME_STR}, + {MSG_APP_TITLE,(STRPTR)MSG_APP_TITLE_STR}, + {MSG_APP_ABOUT,(STRPTR)MSG_APP_ABOUT_STR}, + {MSG_APP_COPYRIGHT,(STRPTR)MSG_APP_COPYRIGHT_STR}, + {MSG_APP_AUTOR,(STRPTR)MSG_APP_AUTOR_STR}, + {MSG_APP_BASE,(STRPTR)MSG_APP_BASE_STR}, + {MSG_WINDOW_TITLE,(STRPTR)MSG_WINDOW_TITLE_STR}, + {MSG_INFO_TITLE,(STRPTR)MSG_INFO_TITLE_STR}, + {MSG_CLOSE_SCREEN,(STRPTR)MSG_CLOSE_SCREEN_STR}, + {MSG_CLOSE_WINDOW,(STRPTR)MSG_CLOSE_WINDOW_STR}, + {MSG_YES_NO,(STRPTR)MSG_YES_NO_STR}, + {MSG_CONTINUE,(STRPTR)MSG_CONTINUE_STR}, + {MSG_BTN_KILL,(STRPTR)MSG_BTN_KILL_STR}, + {MSG_BTN_FRONT,(STRPTR)MSG_BTN_FRONT_STR}, + {MSG_BTN_BACK,(STRPTR)MSG_BTN_BACK_STR}, + {MSG_BTN_MOVE,(STRPTR)MSG_BTN_MOVE_STR}, + {MSG_BTN_ACTIVATE,(STRPTR)MSG_BTN_ACTIVATE_STR}, + {MSG_BTN_ZIP,(STRPTR)MSG_BTN_ZIP_STR}, + {MSG_BTN_HIDE,(STRPTR)MSG_BTN_HIDE_STR}, + {MSG_BTN_SHOW,(STRPTR)MSG_BTN_SHOW_STR}, + {MSG_BTN_UPDATE_LIST,(STRPTR)MSG_BTN_UPDATE_LIST_STR}, + {MSG_BTN_RESCUE_ALL,(STRPTR)MSG_BTN_RESCUE_ALL_STR}, + {MSG_BTN_SHOW_ALL,(STRPTR)MSG_BTN_SHOW_ALL_STR}, + {MSG_BTN_RETHING,(STRPTR)MSG_BTN_RETHING_STR}, + {MSG_BTN_ABOUT,(STRPTR)MSG_BTN_ABOUT_STR}, + {MSG_SCREEN_WINDOW_LIST,(STRPTR)MSG_SCREEN_WINDOW_LIST_STR}, + {MSG_MENU_PROJECT,(STRPTR)MSG_MENU_PROJECT_STR}, + {MSG_MENU_ABOUT,(STRPTR)MSG_MENU_ABOUT_STR}, + {MSG_MENU_QUIT,(STRPTR)MSG_MENU_QUIT_STR}, + {MSG_MENU_WIN_LIST,(STRPTR)MSG_MENU_WIN_LIST_STR}, + {MSG_MENU_UPDATE_LIST,(STRPTR)MSG_MENU_UPDATE_LIST_STR}, + {MSG_MENU_KILL,(STRPTR)MSG_MENU_KILL_STR}, + {MSG_MENU_TO_FRONT,(STRPTR)MSG_MENU_TO_FRONT_STR}, + {MSG_MENU_TO_BACK,(STRPTR)MSG_MENU_TO_BACK_STR}, + {MSG_MENU_TO_ORIGIN,(STRPTR)MSG_MENU_TO_ORIGIN_STR}, + {MSG_MENU_ACTIVATE,(STRPTR)MSG_MENU_ACTIVATE_STR}, + {MSG_MENU_ZIP,(STRPTR)MSG_MENU_ZIP_STR}, + {MSG_MENU_HIDE,(STRPTR)MSG_MENU_HIDE_STR}, + {MSG_MENU_SHOW,(STRPTR)MSG_MENU_SHOW_STR}, + {MSG_MENU_INFO,(STRPTR)MSG_MENU_INFO_STR}, + {MSG_MENU_GENERIC,(STRPTR)MSG_MENU_GENERIC_STR}, + {MSG_MENU_RESCUE_ALL,(STRPTR)MSG_MENU_RESCUE_ALL_STR}, + {MSG_MENU_SHOW_ALL,(STRPTR)MSG_MENU_SHOW_ALL_STR}, + {MSG_MENU_RETHINGDISPLAY,(STRPTR)MSG_MENU_RETHINGDISPLAY_STR}, + {MSG_ARRAY_WINDOW,(STRPTR)MSG_ARRAY_WINDOW_STR}, + {MSG_ARRAY_SCREEN,(STRPTR)MSG_ARRAY_SCREEN_STR}, + {MSG_ARRAY_0_TYPE,(STRPTR)MSG_ARRAY_0_TYPE_STR}, + {MSG_ARRAY_1_ADDRESS,(STRPTR)MSG_ARRAY_1_ADDRESS_STR}, + {MSG_ARRAY_2_SIZE,(STRPTR)MSG_ARRAY_2_SIZE_STR}, + {MSG_ARRAY_3_POSITION,(STRPTR)MSG_ARRAY_3_POSITION_STR}, + {MSG_ARRAY_4_STATUS,(STRPTR)MSG_ARRAY_4_STATUS_STR}, + {MSG_ARRAY_5_TITLE,(STRPTR)MSG_ARRAY_5_TITLE_STR}, + {MSG_COL_SCREEN,(STRPTR)MSG_COL_SCREEN_STR}, + {MSG_COL_SCR_ADDRESS,(STRPTR)MSG_COL_SCR_ADDRESS_STR}, + {MSG_COL_SCR_LEFTEDGE,(STRPTR)MSG_COL_SCR_LEFTEDGE_STR}, + {MSG_COL_SCR_TOPEDGE,(STRPTR)MSG_COL_SCR_TOPEDGE_STR}, + {MSG_COL_SCR_WIDTH,(STRPTR)MSG_COL_SCR_WIDTH_STR}, + {MSG_COL_SCR_HEIGHT,(STRPTR)MSG_COL_SCR_HEIGHT_STR}, + {MSG_COL_SCR_FLAGS,(STRPTR)MSG_COL_SCR_FLAGS_STR}, + {MSG_COL_SCR_TITLE,(STRPTR)MSG_COL_SCR_TITLE_STR}, + {MSG_COL_SCR_DEFAULTIT,(STRPTR)MSG_COL_SCR_DEFAULTIT_STR}, + {MSG_COL_SCR_FRSTWIN,(STRPTR)MSG_COL_SCR_FRSTWIN_STR}, + {MSG_COL_WIDOW,(STRPTR)MSG_COL_WIDOW_STR}, + {MSG_COL_WIN_ADDRESS,(STRPTR)MSG_COL_WIN_ADDRESS_STR}, + {MSG_COL_WIN_NEXTWIN,(STRPTR)MSG_COL_WIN_NEXTWIN_STR}, + {MSG_COL_WIN_LEFTEDGE,(STRPTR)MSG_COL_WIN_LEFTEDGE_STR}, + {MSG_COL_WIN_TOPEDGE,(STRPTR)MSG_COL_WIN_TOPEDGE_STR}, + {MSG_COL_WIN_WIDTH,(STRPTR)MSG_COL_WIN_WIDTH_STR}, + {MSG_COL_WIN_HEIGHT,(STRPTR)MSG_COL_WIN_HEIGHT_STR}, + {MSG_COL_WIN_MINWIDTH,(STRPTR)MSG_COL_WIN_MINWIDTH_STR}, + {MSG_COL_WIN_MINHEIGHT,(STRPTR)MSG_COL_WIN_MINHEIGHT_STR}, + {MSG_COL_WIN_MAXWIDTH,(STRPTR)MSG_COL_WIN_MAXWIDTH_STR}, + {MSG_COL_WIN_MAXHEIGHT,(STRPTR)MSG_COL_WIN_MAXHEIGHT_STR}, + {MSG_COL_WIN_FLAGS,(STRPTR)MSG_COL_WIN_FLAGS_STR}, + {MSG_COL_WIN_IDCMPFLAGS,(STRPTR)MSG_COL_WIN_IDCMPFLAGS_STR}, + {MSG_COL_WIN_TITLE,(STRPTR)MSG_COL_WIN_TITLE_STR}, + {MSG_COL_WIN_REQCOUNT,(STRPTR)MSG_COL_WIN_REQCOUNT_STR}, + {MSG_COL_WIN_WSCREEN,(STRPTR)MSG_COL_WIN_WSCREEN_STR}, + {MSG_COL_WIN_BORDERLEFT,(STRPTR)MSG_COL_WIN_BORDERLEFT_STR}, + {MSG_COL_WIN_BORDERTOP,(STRPTR)MSG_COL_WIN_BORDERTOP_STR}, + {MSG_COL_WIN_BORDERRIGHT,(STRPTR)MSG_COL_WIN_BORDERRIGHT_STR}, + {MSG_COL_WIN_BORDERBOTTOM,(STRPTR)MSG_COL_WIN_BORDERBOTTOM_STR}, + {MSG_COL_WIN_PARENTWIN,(STRPTR)MSG_COL_WIN_PARENTWIN_STR}, + {MSG_COL_WIN_FIRSTCHILD,(STRPTR)MSG_COL_WIN_FIRSTCHILD_STR}, + {MSG_COL_WIN_PARENT,(STRPTR)MSG_COL_WIN_PARENT_STR}, + {MSG_COL_WIN_DESCENDANT,(STRPTR)MSG_COL_WIN_DESCENDANT_STR}, + {0,NULL} +}; + +#endif /* CATCOMP_ARRAY */ + +/***************************************************************/ + +#ifdef CATCOMP_BLOCK + +#error CATCOMP_BLOCK not supported by this SD + +#endif /* CATCOMP_BLOCK */ + +/***************************************************************/ + +#ifdef CATCOMP_CODE + +#error CATCOMP_CODE not supported by this SD + +#endif /* CATCOMP_CODE */ + +/***************************************************************/ + + +#endif /* WIMP_STRINGS_H */ From 09c0662c9f664b77bb7f110f9a349307b7b4f1f4 Mon Sep 17 00:00:00 2001 From: WDrijver Date: Fri, 27 Dec 2024 12:47:52 +0100 Subject: [PATCH 2/5] Update Makefile Clean (remove /config/features.status) --- Makefile.in | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Makefile.in b/Makefile.in index 30a5c25a068..78b0d796ad4 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1,4 +1,4 @@ -# Copyright © 2000-2020, The AROS Development Team. All rights reserved. +# Copyright � 2000-2020, The AROS Development Team. All rights reserved. # $Id$ # # Main makefile for AROS @@ -284,7 +284,8 @@ clean: $(TOOLDIR)/$(AROS_TARGET_CPU)-$(AROS_TARGET_ARCH)$(AROS_TARGET_SUFFIX)-aros-gcc \ $(TOOLDIR)/$(AROS_TARGET_CPU)-$(AROS_TARGET_ARCH)$(AROS_TARGET_SUFFIX)-aros-ld \ $(GENDIR)/scripts/genshared $(TOOLDIR)/genmf.py \ - tools/adflib/myconf.aros tools/collect-aros/env.h + tools/adflib/myconf.aros tools/collect-aros/env.h \ + config/features.status # Clean the sources and tools arch-clean: clean From 6bf14b9d3c63de06bf06debf69dbcf477367174f Mon Sep 17 00:00:00 2001 From: WDrijver Date: Fri, 27 Dec 2024 12:55:03 +0100 Subject: [PATCH 3/5] autoreconf (update configure and aclocal.m4) --- aclocal.m4 | 295 +- config/host-conf.h.in | 18 +- config/host-conf.h.in~ | 208 + configure | 10689 +++++++++++++---------- configure~ | 18008 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 24460 insertions(+), 4758 deletions(-) create mode 100644 config/host-conf.h.in~ create mode 100755 configure~ diff --git a/aclocal.m4 b/aclocal.m4 index 051d2a30821..e3c50d18430 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -1,6 +1,6 @@ -# generated automatically by aclocal 1.16.1 -*- Autoconf -*- +# generated automatically by aclocal 1.16.5 -*- Autoconf -*- -# Copyright (C) 1996-2018 Free Software Foundation, Inc. +# Copyright (C) 1996-2021 Free Software Foundation, Inc. # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, @@ -198,7 +198,7 @@ int main(int argc, char *argv[]) rm -f conf.sdltest ]) -# Copyright (C) 1999-2018 Free Software Foundation, Inc. +# Copyright (C) 1999-2021 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, @@ -233,6 +233,7 @@ AC_DEFUN([AM_PATH_PYTHON], dnl supported. (2.0 was released on October 16, 2000). m4_define_default([_AM_PYTHON_INTERPRETER_LIST], [python python2 python3 dnl + python3.11 python3.10 dnl python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 dnl python3.2 python3.1 python3.0 dnl python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 dnl @@ -277,34 +278,141 @@ AC_DEFUN([AM_PATH_PYTHON], ]) if test "$PYTHON" = :; then - dnl Run any user-specified action, or abort. + dnl Run any user-specified action, or abort. m4_default([$3], [AC_MSG_ERROR([no suitable Python interpreter found])]) else - dnl Query Python for its version number. Getting [:3] seems to be - dnl the best way to do this; it's what "site.py" does in the standard - dnl library. - + dnl Query Python for its version number. Although site.py simply uses + dnl sys.version[:3], printing that failed with Python 3.10, since the + dnl trailing zero was eliminated. So now we output just the major + dnl and minor version numbers, as numbers. Apparently the tertiary + dnl version is not of interest. + dnl AC_CACHE_CHECK([for $am_display_PYTHON version], [am_cv_python_version], - [am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[[:3]])"`]) + [am_cv_python_version=`$PYTHON -c "import sys; print ('%u.%u' % sys.version_info[[:2]])"`]) AC_SUBST([PYTHON_VERSION], [$am_cv_python_version]) - dnl Use the values of $prefix and $exec_prefix for the corresponding - dnl values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX. These are made - dnl distinct variables so they can be overridden if need be. However, - dnl general consensus is that you shouldn't need this ability. - - AC_SUBST([PYTHON_PREFIX], ['${prefix}']) - AC_SUBST([PYTHON_EXEC_PREFIX], ['${exec_prefix}']) - - dnl At times (like when building shared libraries) you may want + dnl At times, e.g., when building shared libraries, you may want dnl to know which OS platform Python thinks this is. - + dnl AC_CACHE_CHECK([for $am_display_PYTHON platform], [am_cv_python_platform], [am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`]) AC_SUBST([PYTHON_PLATFORM], [$am_cv_python_platform]) - # Just factor out some code duplication. + dnl emacs-page + dnl If --with-python-sys-prefix is given, use the values of sys.prefix + dnl and sys.exec_prefix for the corresponding values of PYTHON_PREFIX + dnl and PYTHON_EXEC_PREFIX. Otherwise, use the GNU ${prefix} and + dnl ${exec_prefix} variables. + dnl + dnl The two are made distinct variables so they can be overridden if + dnl need be, although general consensus is that you shouldn't need + dnl this separation. + dnl + dnl Also allow directly setting the prefixes via configure options, + dnl overriding any default. + dnl + if test "x$prefix" = xNONE; then + am__usable_prefix=$ac_default_prefix + else + am__usable_prefix=$prefix + fi + + # Allow user to request using sys.* values from Python, + # instead of the GNU $prefix values. + AC_ARG_WITH([python-sys-prefix], + [AS_HELP_STRING([--with-python-sys-prefix], + [use Python's sys.prefix and sys.exec_prefix values])], + [am_use_python_sys=:], + [am_use_python_sys=false]) + + # Allow user to override whatever the default Python prefix is. + AC_ARG_WITH([python_prefix], + [AS_HELP_STRING([--with-python_prefix], + [override the default PYTHON_PREFIX])], + [am_python_prefix_subst=$withval + am_cv_python_prefix=$withval + AC_MSG_CHECKING([for explicit $am_display_PYTHON prefix]) + AC_MSG_RESULT([$am_cv_python_prefix])], + [ + if $am_use_python_sys; then + # using python sys.prefix value, not GNU + AC_CACHE_CHECK([for python default $am_display_PYTHON prefix], + [am_cv_python_prefix], + [am_cv_python_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.prefix)"`]) + + dnl If sys.prefix is a subdir of $prefix, replace the literal value of + dnl $prefix with a variable reference so it can be overridden. + case $am_cv_python_prefix in + $am__usable_prefix*) + am__strip_prefix=`echo "$am__usable_prefix" | sed 's|.|.|g'` + am_python_prefix_subst=`echo "$am_cv_python_prefix" | sed "s,^$am__strip_prefix,\\${prefix},"` + ;; + *) + am_python_prefix_subst=$am_cv_python_prefix + ;; + esac + else # using GNU prefix value, not python sys.prefix + am_python_prefix_subst='${prefix}' + am_python_prefix=$am_python_prefix_subst + AC_MSG_CHECKING([for GNU default $am_display_PYTHON prefix]) + AC_MSG_RESULT([$am_python_prefix]) + fi]) + # Substituting python_prefix_subst value. + AC_SUBST([PYTHON_PREFIX], [$am_python_prefix_subst]) + + # emacs-page Now do it all over again for Python exec_prefix, but with yet + # another conditional: fall back to regular prefix if that was specified. + AC_ARG_WITH([python_exec_prefix], + [AS_HELP_STRING([--with-python_exec_prefix], + [override the default PYTHON_EXEC_PREFIX])], + [am_python_exec_prefix_subst=$withval + am_cv_python_exec_prefix=$withval + AC_MSG_CHECKING([for explicit $am_display_PYTHON exec_prefix]) + AC_MSG_RESULT([$am_cv_python_exec_prefix])], + [ + # no explicit --with-python_exec_prefix, but if + # --with-python_prefix was given, use its value for python_exec_prefix too. + AS_IF([test -n "$with_python_prefix"], + [am_python_exec_prefix_subst=$with_python_prefix + am_cv_python_exec_prefix=$with_python_prefix + AC_MSG_CHECKING([for python_prefix-given $am_display_PYTHON exec_prefix]) + AC_MSG_RESULT([$am_cv_python_exec_prefix])], + [ + # Set am__usable_exec_prefix whether using GNU or Python values, + # since we use that variable for pyexecdir. + if test "x$exec_prefix" = xNONE; then + am__usable_exec_prefix=$am__usable_prefix + else + am__usable_exec_prefix=$exec_prefix + fi + # + if $am_use_python_sys; then # using python sys.exec_prefix, not GNU + AC_CACHE_CHECK([for python default $am_display_PYTHON exec_prefix], + [am_cv_python_exec_prefix], + [am_cv_python_exec_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)"`]) + dnl If sys.exec_prefix is a subdir of $exec_prefix, replace the + dnl literal value of $exec_prefix with a variable reference so it can + dnl be overridden. + case $am_cv_python_exec_prefix in + $am__usable_exec_prefix*) + am__strip_prefix=`echo "$am__usable_exec_prefix" | sed 's|.|.|g'` + am_python_exec_prefix_subst=`echo "$am_cv_python_exec_prefix" | sed "s,^$am__strip_prefix,\\${exec_prefix},"` + ;; + *) + am_python_exec_prefix_subst=$am_cv_python_exec_prefix + ;; + esac + else # using GNU $exec_prefix, not python sys.exec_prefix + am_python_exec_prefix_subst='${exec_prefix}' + am_python_exec_prefix=$am_python_exec_prefix_subst + AC_MSG_CHECKING([for GNU default $am_display_PYTHON exec_prefix]) + AC_MSG_RESULT([$am_python_exec_prefix]) + fi])]) + # Substituting python_exec_prefix_subst. + AC_SUBST([PYTHON_EXEC_PREFIX], [$am_python_exec_prefix_subst]) + + # Factor out some code duplication into this shell variable. am_python_setup_sysconfig="\ import sys # Prefer sysconfig over distutils.sysconfig, for better compatibility @@ -324,96 +432,109 @@ try: except ImportError: pass" - dnl Set up 4 directories: + dnl emacs-page Set up 4 directories: - dnl pythondir -- where to install python scripts. This is the - dnl site-packages directory, not the python standard library - dnl directory like in previous automake betas. This behavior - dnl is more consistent with lispdir.m4 for example. + dnl 1. pythondir: where to install python scripts. This is the + dnl site-packages directory, not the python standard library + dnl directory like in previous automake betas. This behavior + dnl is more consistent with lispdir.m4 for example. dnl Query distutils for this directory. - AC_CACHE_CHECK([for $am_display_PYTHON script directory], - [am_cv_python_pythondir], - [if test "x$prefix" = xNONE - then - am_py_prefix=$ac_default_prefix - else - am_py_prefix=$prefix - fi - am_cv_python_pythondir=`$PYTHON -c " + dnl + AC_CACHE_CHECK([for $am_display_PYTHON script directory (pythondir)], + [am_cv_python_pythondir], + [if test "x$am_cv_python_prefix" = x; then + am_py_prefix=$am__usable_prefix + else + am_py_prefix=$am_cv_python_prefix + fi + am_cv_python_pythondir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('purelib', scheme, vars={'base':'$am_py_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pythondir in - $am_py_prefix*) - am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` - am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` - ;; - *) - case $am_py_prefix in - /usr|/System*) ;; - *) - am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,\\${PYTHON_PREFIX},"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) am_cv_python_pythondir="\${PYTHON_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac - ]) + ;; + esac + ]) AC_SUBST([pythondir], [$am_cv_python_pythondir]) - dnl pkgpythondir -- $PACKAGE directory under pythondir. Was - dnl PYTHON_SITE_PACKAGE in previous betas, but this naming is - dnl more consistent with the rest of automake. - + dnl 2. pkgpythondir: $PACKAGE directory under pythondir. Was + dnl PYTHON_SITE_PACKAGE in previous betas, but this naming is + dnl more consistent with the rest of automake. + dnl AC_SUBST([pkgpythondir], [\${pythondir}/$PACKAGE]) - dnl pyexecdir -- directory for installing python extension modules - dnl (shared libraries) + dnl 3. pyexecdir: directory for installing python extension modules + dnl (shared libraries). dnl Query distutils for this directory. - AC_CACHE_CHECK([for $am_display_PYTHON extension module directory], - [am_cv_python_pyexecdir], - [if test "x$exec_prefix" = xNONE - then - am_py_exec_prefix=$am_py_prefix - else - am_py_exec_prefix=$exec_prefix - fi - am_cv_python_pyexecdir=`$PYTHON -c " + dnl + AC_CACHE_CHECK([for $am_display_PYTHON extension module directory (pyexecdir)], + [am_cv_python_pyexecdir], + [if test "x$am_cv_python_exec_prefix" = x; then + am_py_exec_prefix=$am__usable_exec_prefix + else + am_py_exec_prefix=$am_cv_python_exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase':'$am_py_exec_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_exec_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pyexecdir in - $am_py_exec_prefix*) - am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` - am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` - ;; - *) - case $am_py_exec_prefix in - /usr|/System*) ;; - *) - am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,\\${PYTHON_EXEC_PREFIX},"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) am_cv_python_pyexecdir="\${PYTHON_EXEC_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac - ]) + ;; + esac + ]) AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir]) - dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE) - + dnl 4. pkgpyexecdir: $(pyexecdir)/$(PACKAGE) + dnl AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE]) dnl Run any user-specified action. $2 fi - ]) @@ -436,7 +557,7 @@ for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[[i]] sys.exit(sys.hexversion < minverhex)" AS_IF([AM_RUN_LOG([$1 -c "$prog"])], [$3], [$4])]) -# Copyright (C) 2001-2018 Free Software Foundation, Inc. +# Copyright (C) 2001-2021 Free Software Foundation, Inc. # # This file is free software; the Free Software Foundation # gives unlimited permission to copy and/or distribute it, diff --git a/config/host-conf.h.in b/config/host-conf.h.in index caa40a96173..012f7628576 100644 --- a/config/host-conf.h.in +++ b/config/host-conf.h.in @@ -32,9 +32,6 @@ /* Define to 1 if you have the `makecontext' function. */ #undef HAVE_MAKECONTEXT -/* Define to 1 if you have the header file. */ -#undef HAVE_MEMORY_H - /* Define to 1 if you have a working `mmap' system call. */ #undef HAVE_MMAP @@ -62,6 +59,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H +/* Define to 1 if you have the header file. */ +#undef HAVE_STDIO_H + /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H @@ -139,6 +139,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TIME_H + /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H @@ -183,10 +186,13 @@ /* Define to 1 if the `S_IS*' macros in do not work properly. */ #undef STAT_MACROS_BROKEN -/* Define to 1 if you have the ANSI C header files. */ +/* Define to 1 if all of the C90 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 -/* Define to 1 if you can safely include both and . */ +/* Define to 1 if you can safely include both and . This + macro is obsolete. */ #undef TIME_WITH_SYS_TIME /* Define to 1 if your declares `struct tm'. */ @@ -198,7 +204,7 @@ /* Define to `long int' if does not define. */ #undef off_t -/* Define to `int' if does not define. */ +/* Define as a signed integer type capable of holding a process identifier. */ #undef pid_t /* Define to `unsigned int' if does not define. */ diff --git a/config/host-conf.h.in~ b/config/host-conf.h.in~ new file mode 100644 index 00000000000..caa40a96173 --- /dev/null +++ b/config/host-conf.h.in~ @@ -0,0 +1,208 @@ +/* config/host-conf.h.in. Generated from configure.in by autoheader. */ + +/* Define to 1 if you have the `clone' function. */ +#undef HAVE_CLONE + +/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +#undef HAVE_DECL_TZNAME + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#undef HAVE_DIRENT_H + +/* Define to 1 if you have the `getcontext' function. */ +#undef HAVE_GETCONTEXT + +/* Define to 1 if you have the `getpagesize' function. */ +#undef HAVE_GETPAGESIZE + +/* Define to 1 if you have the header file. */ +#undef HAVE_GL_GLX_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the `kqueue' function. */ +#undef HAVE_KQUEUE + +/* Define to 1 if you have the `kse_create' function. */ +#undef HAVE_KSE_CREATE + +/* Define to 1 if you have the `makecontext' function. */ +#undef HAVE_MAKECONTEXT + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define to 1 if you have a working `mmap' system call. */ +#undef HAVE_MMAP + +/* Define to 1 if you have the header file, and it defines `DIR'. */ +#undef HAVE_NDIR_H + +/* Define to 1 if you have the `rfork_thread' function. */ +#undef HAVE_RFORK_THREAD + +/* Define to 1 if you have the `sa_register' function. */ +#undef HAVE_SA_REGISTER + +/* Define to 1 if you have the `setcontext' function. */ +#undef HAVE_SETCONTEXT + +/* Define to 1 if you have the `sigaltstack' function. */ +#undef HAVE_SIGALTSTACK + +/* Define to 1 if you have the `statfs' function. */ +#undef HAVE_STATFS + +/* Define to 1 if you have the `statvfs' function. */ +#undef HAVE_STATVFS + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if `st_blksize' is a member of `struct stat'. */ +#undef HAVE_STRUCT_STAT_ST_BLKSIZE + +/* Define to 1 if `st_blocks' is a member of `struct stat'. */ +#undef HAVE_STRUCT_STAT_ST_BLOCKS + +/* Define to 1 if `st_rdev' is a member of `struct stat'. */ +#undef HAVE_STRUCT_STAT_ST_RDEV + +/* Define to 1 if `tm_gmtoff' is a member of `struct tm'. */ +#undef HAVE_STRUCT_TM_TM_GMTOFF + +/* Define to 1 if `tm_zone' is a member of `struct tm'. */ +#undef HAVE_STRUCT_TM_TM_ZONE + +/* Define to 1 if your `struct stat' has `st_blksize'. Deprecated, use + `HAVE_STRUCT_STAT_ST_BLKSIZE' instead. */ +#undef HAVE_ST_BLKSIZE + +/* Define to 1 if your `struct stat' has `st_blocks'. Deprecated, use + `HAVE_STRUCT_STAT_ST_BLOCKS' instead. */ +#undef HAVE_ST_BLOCKS + +/* Define to 1 if your `struct stat' has `st_rdev'. Deprecated, use + `HAVE_STRUCT_STAT_ST_RDEV' instead. */ +#undef HAVE_ST_RDEV + +/* Define to 1 if you have the `swapcontext' function. */ +#undef HAVE_SWAPCONTEXT + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYSEXITS_H + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#undef HAVE_SYS_DIR_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_IPC_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_MMAN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_MMAP_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_MOUNT_H + +/* Define to 1 if you have the header file, and it defines `DIR'. + */ +#undef HAVE_SYS_NDIR_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_PARAM_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_SHM_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STATFS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STATVFS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_VFS_H + +/* Define to 1 if you have that is POSIX.1 compatible. */ +#undef HAVE_SYS_WAIT_H + +/* Define to 1 if you have the `thr_create' function. */ +#undef HAVE_THR_CREATE + +/* Define to 1 if your `struct tm' has `tm_zone'. Deprecated, use + `HAVE_STRUCT_TM_TM_ZONE' instead. */ +#undef HAVE_TM_ZONE + +/* Define to 1 if you don't have `tm_zone' but do have the external array + `tzname'. */ +#undef HAVE_TZNAME + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if the `S_IS*' macros in do not work properly. */ +#undef STAT_MACROS_BROKEN + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Define to 1 if you can safely include both and . */ +#undef TIME_WITH_SYS_TIME + +/* Define to 1 if your declares `struct tm'. */ +#undef TM_IN_SYS_TIME + +/* Define to `int' if doesn't define. */ +#undef gid_t + +/* Define to `long int' if does not define. */ +#undef off_t + +/* Define to `int' if does not define. */ +#undef pid_t + +/* Define to `unsigned int' if does not define. */ +#undef size_t + +/* Define to `int' if doesn't define. */ +#undef uid_t diff --git a/configure b/configure index f257323fdd9..a60057e36f3 100755 --- a/configure +++ b/configure @@ -1,9 +1,10 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69. +# Generated by GNU Autoconf 2.71. # # -# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation, +# Inc. # # # This configure script is free software; the Free Software Foundation @@ -14,14 +15,16 @@ # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : +as_nop=: +if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else +else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( @@ -31,46 +34,46 @@ esac fi + +# Reset variables that may have inherited troublesome values from +# the environment. + +# IFS needs to be set, to space, tab, and newline, in precisely that order. +# (If _AS_PATH_WALK were called with IFS unset, it would have the +# side effect of setting IFS to empty, thus disabling word splitting.) +# Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi +IFS=" "" $as_nl" + +PS1='$ ' +PS2='> ' +PS4='+ ' + +# Ensure predictable behavior from utilities with locale-dependent output. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# We cannot yet rely on "unset" to work, but we need these variables +# to be unset--not just set to an empty or harmless value--now, to +# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct +# also avoids known problems related to "unset" and subshell syntax +# in other old shells (e.g. bash 2.01 and pdksh 5.2.14). +for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH +do eval test \${$as_var+y} \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done + +# Ensure that fds 0, 1, and 2 are open. +if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi +if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then +if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || @@ -79,13 +82,6 @@ if test "${PATH_SEPARATOR+set}" != set; then fi -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( @@ -94,8 +90,12 @@ case $0 in #(( for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS @@ -107,30 +107,10 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - $as_echo "$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 -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. @@ -152,20 +132,22 @@ esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. -$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 -as_fn_exit 255 +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. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then - as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + as_bourne_compatible="as_nop=: +if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST -else +else \$as_nop case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( @@ -185,42 +167,53 @@ as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } -if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : +if ( set x; as_fn_ret_success y && test x = \"\$1\" ) +then : -else +else \$as_nop exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 +blah=\$(echo \$(echo blah)) +test x\"\$blah\" = xblah || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" - if (eval "$as_required") 2>/dev/null; then : + if (eval "$as_required") 2>/dev/null +then : as_have_required=yes -else +else $as_nop as_have_required=no fi - if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null +then : -else +else $as_nop as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. - as_shell=$as_dir/$as_base + as_shell=$as_dir$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null +then : CONFIG_SHELL=$as_shell as_have_required=yes - if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null +then : break 2 fi fi @@ -228,14 +221,21 @@ fi esac as_found=false done -$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : - CONFIG_SHELL=$SHELL as_have_required=yes -fi; } IFS=$as_save_IFS +if $as_found +then : + +else $as_nop + if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null +then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi +fi - if test "x$CONFIG_SHELL" != x; then : + if test "x$CONFIG_SHELL" != x +then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also @@ -253,18 +253,19 @@ esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. -$as_echo "$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 : - $as_echo "$0: This script requires a shell more modern than all" - $as_echo "$0: the shells that I found on your system." - if test x${ZSH_VERSION+set} = xset ; then - $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" - $as_echo "$0: be upgraded to zsh 4.3.4 or later." + 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." + 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." else - $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, + printf "%s\n" "$0: Please tell bug-autoconf@gnu.org about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." @@ -291,6 +292,7 @@ as_fn_unset () } as_unset=as_fn_unset + # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. @@ -308,6 +310,14 @@ as_fn_exit () as_fn_set_status $1 exit $1 } # as_fn_exit +# as_fn_nop +# --------- +# Do nothing but, unlike ":", preserve the value of $?. +as_fn_nop () +{ + return $? +} +as_nop=as_fn_nop # as_fn_mkdir_p # ------------- @@ -322,7 +332,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`$as_echo "$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" @@ -331,7 +341,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | +printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -370,12 +380,13 @@ as_fn_executable_p () # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null +then : eval 'as_fn_append () { eval $1+=\$2 }' -else +else $as_nop as_fn_append () { eval $1=\$$1\$2 @@ -387,18 +398,27 @@ fi # as_fn_append # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null +then : eval 'as_fn_arith () { as_val=$(( $* )) }' -else +else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith +# as_fn_nop +# --------- +# Do nothing but, unlike ":", preserve the value of $?. +as_fn_nop () +{ + return $? +} +as_nop=as_fn_nop # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- @@ -410,9 +430,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 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - $as_echo "$as_me: error: $2" >&2 + printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error @@ -439,7 +459,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | +printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -483,7 +503,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || - { $as_echo "$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 @@ -497,6 +517,10 @@ 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*) @@ -510,6 +534,13 @@ case `echo -n x` in #((((( 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_echo='printf %s\n' +as_echo_n='printf %s' + + rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -575,51 +606,47 @@ MFLAGS= MAKEFLAGS= # Identity of this package. -PACKAGE_NAME= -PACKAGE_TARNAME= -PACKAGE_VERSION= -PACKAGE_STRING= -PACKAGE_BUGREPORT= -PACKAGE_URL= +PACKAGE_NAME='' +PACKAGE_TARNAME='' +PACKAGE_VERSION='' +PACKAGE_STRING='' +PACKAGE_BUGREPORT='' +PACKAGE_URL='' ac_unique_file="mmakefile" # Factoring default headers for most tests. ac_includes_default="\ -#include -#ifdef HAVE_SYS_TYPES_H -# include -#endif -#ifdef HAVE_SYS_STAT_H -# include +#include +#ifdef HAVE_STDIO_H +# include #endif -#ifdef STDC_HEADERS +#ifdef HAVE_STDLIB_H # include -# include -#else -# ifdef HAVE_STDLIB_H -# include -# endif #endif #ifdef HAVE_STRING_H -# if !defined STDC_HEADERS && defined HAVE_MEMORY_H -# include -# endif # include #endif -#ifdef HAVE_STRINGS_H -# include -#endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif #ifdef HAVE_UNISTD_H # include #endif" -ac_header_list= +ac_header_c_list= +ac_func_c_list= ac_subst_vars='LTLIBOBJS config_prefs_set aros_usb30_code @@ -834,9 +861,9 @@ pkgpyexecdir pyexecdir pkgpythondir pythondir -PYTHON_PLATFORM PYTHON_EXEC_PREFIX PYTHON_PREFIX +PYTHON_PLATFORM PYTHON_VERSION PYTHON PATCH @@ -934,6 +961,9 @@ enable_option_checking with_aros_prefs with_c_compiler with_cxx_compiler +with_python_sys_prefix +with_python_prefix +with_python_exec_prefix enable_libpng_config with_toolchain enable_lto @@ -1075,8 +1105,6 @@ do *) ac_optarg=yes ;; esac - # Accept the important Cygnus configure options, so we can diagnose typos. - case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; @@ -1117,9 +1145,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" + as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1143,9 +1171,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" + as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1356,9 +1384,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" + as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1372,9 +1400,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" + as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1418,9 +1446,9 @@ Try \`$0 --help' for more information" *) # FIXME: should be removed in autoconf 3.0. - $as_echo "$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 && - $as_echo "$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}" ;; @@ -1436,7 +1464,7 @@ if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; - *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi @@ -1500,7 +1528,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_myself" | +printf "%s\n" X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -1696,6 +1724,11 @@ Optional Packages: Use specified c compiler for building AROS --with-cxx-compiler=VERSION Use specified c++ compiler building AROS + --with-python-sys-prefix + use Python's sys.prefix and sys.exec_prefix values + --with-python_prefix override the default PYTHON_PREFIX + --with-python_exec_prefix + override the default PYTHON_EXEC_PREFIX --with-toolchain=family Which toolchain family to crosscompile with (defaults to gnu) --with-kernel-gcc-version=VERSION @@ -1791,9 +1824,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=/`$as_echo "$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=`$as_echo "$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/ ;; @@ -1821,7 +1854,8 @@ esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } - # Check for guested configure. + # Check for configure.gnu first; this name is used for a wrapper for + # Metaconfig's "Configure" on case-insensitive file systems. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive @@ -1829,7 +1863,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix echo && $SHELL "$ac_srcdir/configure" --help=recursive else - $as_echo "$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 @@ -1839,9 +1873,9 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF configure -generated by GNU Autoconf 2.69 +generated by GNU Autoconf 2.71 -Copyright (C) 2012 Free Software Foundation, Inc. +Copyright (C) 2021 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1858,14 +1892,14 @@ fi ac_fn_cxx_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext + rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" 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\"" -$as_echo "$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 @@ -1873,14 +1907,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - } && test -s conftest.$ac_objext; then : + } && test -s conftest.$ac_objext +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1896,14 +1931,14 @@ fi ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext + rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" 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\"" -$as_echo "$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 @@ -1911,14 +1946,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - } && test -s conftest.$ac_objext; then : + } && test -s conftest.$ac_objext +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1940,7 +1976,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$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 @@ -1948,14 +1984,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - }; then : + } +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1971,14 +2008,14 @@ fi ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext conftest$ac_exeext + rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext if { { ac_try="$ac_link" 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\"" -$as_echo "$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 @@ -1986,17 +2023,18 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext - }; then : + } +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -2011,135 +2049,6 @@ fi } # ac_fn_c_try_link -# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES -# ------------------------------------------------------- -# Tests whether HEADER exists, giving a warning if it cannot be compiled using -# the include files in INCLUDES and setting the cache variable VAR -# accordingly. -ac_fn_c_check_header_mongrel () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval \${$3+:} false; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -else - # Is the header compilable? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 -$as_echo_n "checking $2 usability... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -#include <$2> -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_header_compiler=yes -else - ac_header_compiler=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 -$as_echo "$ac_header_compiler" >&6; } - -# Is the header present? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 -$as_echo_n "checking $2 presence... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include <$2> -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - ac_header_preproc=yes -else - ac_header_preproc=no -fi -rm -f conftest.err conftest.i conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 -$as_echo "$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( - yes:no: ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 -$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; - no:yes:* ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 -$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 -$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 -$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 -$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else - eval "$3=\$ac_header_compiler" -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -fi - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - -} # ac_fn_c_check_header_mongrel - -# ac_fn_c_try_run LINENO -# ---------------------- -# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes -# that executables *can* be run. -ac_fn_c_try_run () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_link" -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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - $as_echo "$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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; }; then : - ac_retval=0 -else - $as_echo "$as_me: program exited with status $ac_status" >&5 - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=$ac_status -fi - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_c_try_run - # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in @@ -2147,26 +2056,28 @@ fi ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 @@ -2178,16 +2089,17 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_member () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 -$as_echo_n "checking for $2.$3... " >&6; } -if eval \${$4+:} false; then : - $as_echo_n "(cached) " >&6 -else + { 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int -main () +main (void) { static $2 ac_aggr; if (ac_aggr.$3) @@ -2196,14 +2108,15 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$4=yes" -else +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int -main () +main (void) { static $2 ac_aggr; if (sizeof ac_aggr.$3) @@ -2212,41 +2125,45 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$4=yes" -else +else $as_nop eval "$4=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$4 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 -# ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES -# --------------------------------------------- +# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR +# ------------------------------------------------------------------ # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR -# accordingly. -ac_fn_c_check_decl () +# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR. +ac_fn_check_decl () { 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 "checking whether $as_decl_name is declared... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 -$as_echo_n "checking whether $as_decl_name is declared... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + eval ac_save_FLAGS=\$$6 + as_fn_append $6 " $5" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { #ifndef $as_decl_name #ifdef __cplusplus @@ -2260,19 +2177,22 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + eval $6=\$ac_save_FLAGS + fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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_decl +} # ac_fn_check_decl # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- @@ -2281,17 +2201,18 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { if (sizeof ($2)) return 0; @@ -2299,12 +2220,13 @@ if (sizeof ($2)) return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { if (sizeof (($2))) return 0; @@ -2312,18 +2234,19 @@ if (sizeof (($2))) return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : -else +else $as_nop eval "$3=yes" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 @@ -2334,11 +2257,12 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. @@ -2346,16 +2270,9 @@ else #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $2 (); below. - Prefer to if __STDC__ is defined, since - exists even on freestanding compilers. */ - -#ifdef __STDC__ -# include -#else -# include -#endif + which can conflict with char $2 (); below. */ +#include #undef $2 /* Override any GCC internal prototype to avoid an error. @@ -2373,35 +2290,99 @@ choke me #endif int -main () +main (void) { return $2 (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that +# executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +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 + (eval "$ac_link") 2>&5 + ac_status=$? + 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 + (eval "$ac_try") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } +then : + ac_retval=0 +else $as_nop + 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 +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run +ac_configure_args_raw= +for ac_arg +do + case $ac_arg in + *\'*) + ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append ac_configure_args_raw " '$ac_arg'" +done + +case $ac_configure_args_raw in + *$as_nl*) + ac_safe_unquote= ;; + *) + 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"`;; +esac + cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by $as_me, which was -generated by GNU Autoconf 2.69. Invocation command line was +generated by GNU Autoconf 2.71. Invocation command line was - $ $0 $@ + $ $0$ac_configure_args_raw _ACEOF exec 5>>config.log @@ -2434,8 +2415,12 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - $as_echo "PATH: $as_dir" + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + printf "%s\n" "PATH: $as_dir" done IFS=$as_save_IFS @@ -2470,7 +2455,7 @@ do | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) - ac_arg=`$as_echo "$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'" ;; @@ -2505,11 +2490,13 @@ done # 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 - $as_echo "## ---------------- ## + printf "%s\n" "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo @@ -2520,8 +2507,8 @@ trap 'exit_status=$? case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$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) ;; #( @@ -2545,7 +2532,7 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; ) echo - $as_echo "## ----------------- ## + printf "%s\n" "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo @@ -2553,14 +2540,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - $as_echo "$ac_var='\''$ac_val'\''" + printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then - $as_echo "## ------------------- ## + printf "%s\n" "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo @@ -2568,15 +2555,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - $as_echo "$ac_var='\''$ac_val'\''" + printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then - $as_echo "## ----------- ## + printf "%s\n" "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo @@ -2584,8 +2571,8 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; echo fi test "$ac_signal" != 0 && - $as_echo "$as_me: caught signal $ac_signal" - $as_echo "$as_me: exit $exit_status" + printf "%s\n" "$as_me: caught signal $ac_signal" + printf "%s\n" "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && @@ -2599,63 +2586,48 @@ ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h -$as_echo "/* confdefs.h */" > confdefs.h +printf "%s\n" "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. -cat >>confdefs.h <<_ACEOF -#define PACKAGE_NAME "$PACKAGE_NAME" -_ACEOF +printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_TARNAME "$PACKAGE_TARNAME" -_ACEOF +printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_VERSION "$PACKAGE_VERSION" -_ACEOF +printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_STRING "$PACKAGE_STRING" -_ACEOF +printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" -_ACEOF +printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_URL "$PACKAGE_URL" -_ACEOF +printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. -ac_site_file1=NONE -ac_site_file2=NONE if test -n "$CONFIG_SITE"; then - # We do not want a PATH search for config.site. - case $CONFIG_SITE in #(( - -*) ac_site_file1=./$CONFIG_SITE;; - */*) ac_site_file1=$CONFIG_SITE;; - *) ac_site_file1=./$CONFIG_SITE;; - esac + ac_site_files="$CONFIG_SITE" elif test "x$prefix" != xNONE; then - ac_site_file1=$prefix/share/config.site - ac_site_file2=$prefix/etc/config.site + ac_site_files="$prefix/share/config.site $prefix/etc/config.site" else - ac_site_file1=$ac_default_prefix/share/config.site - ac_site_file2=$ac_default_prefix/etc/config.site + ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi -for ac_site_file in "$ac_site_file1" "$ac_site_file2" + +for ac_site_file in $ac_site_files do - test "x$ac_site_file" = xNONE && continue - if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 -$as_echo "$as_me: loading site script $ac_site_file" >&6;} + case $ac_site_file in #( + */*) : + ;; #( + *) : + 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;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ - || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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 @@ -2665,144 +2637,752 @@ 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 -$as_echo "$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 -as_fn_append ac_header_list " stdlib.h" -as_fn_append ac_header_list " unistd.h" -as_fn_append ac_header_list " sys/param.h" -# Check that the precious variables saved in the cache have kept the same -# value. -ac_cache_corrupted=false -for ac_var in $ac_precious_vars; do - eval ac_old_set=\$ac_cv_env_${ac_var}_set - eval ac_new_set=\$ac_env_${ac_var}_set - eval ac_old_val=\$ac_cv_env_${ac_var}_value - eval ac_new_val=\$ac_env_${ac_var}_value - case $ac_old_set,$ac_new_set in - set,) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,set) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 -$as_echo "$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` - if test "$ac_old_val_w" != "$ac_new_val_w"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 -$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - ac_cache_corrupted=: - else - { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 -$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} - eval $ac_var=\$ac_old_val - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 -$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 -$as_echo "$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=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; - *) ac_arg=$ac_var=$ac_new_val ;; - esac - case " $ac_configure_args " in - *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) as_fn_append ac_configure_args " '$ac_arg'" ;; - esac - fi -done -if $ac_cache_corrupted; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 -$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} - as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 -fi -## -------------------- ## -## Main body of script. ## -## -------------------- ## +# Test code for whether the C++ compiler supports C++98 (global declarations) +ac_cxx_conftest_cxx98_globals=' +// Does the compiler advertise C++98 conformance? +#if !defined __cplusplus || __cplusplus < 199711L +# error "Compiler does not advertise C++98 conformance" +#endif -ac_ext=c -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 +// These inclusions are to reject old compilers that +// lack the unsuffixed header files. +#include +#include +// and are *not* freestanding headers in C++98. +extern void assert (int); +namespace std { + extern int strcmp (const char *, const char *); +} +// Namespaces, exceptions, and templates were all added after "C++ 2.0". +using std::exception; +using std::strcmp; -ac_aux_dir= -for ac_dir in scripts/autoconf "$srcdir"/scripts/autoconf; do - if test -f "$ac_dir/install-sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install-sh -c" - break - elif test -f "$ac_dir/install.sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install.sh -c" - break - elif test -f "$ac_dir/shtool"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/shtool install -c" +namespace { + +void test_exception_syntax() +{ + try { + throw "test"; + } catch (const char *s) { + // Extra parentheses suppress a warning when building autoconf itself, + // due to lint rules shared with more typical C programs. + assert (!(strcmp) (s, "test")); + } +} + +template struct test_template +{ + T const val; + explicit test_template(T t) : val(t) {} + template T add(U u) { return static_cast(u) + val; } +}; + +} // anonymous namespace +' + +# Test code for whether the C++ compiler supports C++98 (body of main) +ac_cxx_conftest_cxx98_main=' + assert (argc); + assert (! argv[0]); +{ + test_exception_syntax (); + test_template tt (2.0); + assert (tt.add (4) == 6.0); + assert (true && !false); +} +' + +# Test code for whether the C++ compiler supports C++11 (global declarations) +ac_cxx_conftest_cxx11_globals=' +// Does the compiler advertise C++ 2011 conformance? +#if !defined __cplusplus || __cplusplus < 201103L +# error "Compiler does not advertise C++11 conformance" +#endif + +namespace cxx11test +{ + constexpr int get_val() { return 20; } + + struct testinit + { + int i; + double d; + }; + + class delegate + { + public: + delegate(int n) : n(n) {} + delegate(): delegate(2354) {} + + virtual int getval() { return this->n; }; + protected: + int n; + }; + + class overridden : public delegate + { + public: + overridden(int n): delegate(n) {} + virtual int getval() override final { return this->n * 2; } + }; + + class nocopy + { + public: + nocopy(int i): i(i) {} + nocopy() = default; + nocopy(const nocopy&) = delete; + nocopy & operator=(const nocopy&) = delete; + private: + int i; + }; + + // for testing lambda expressions + template Ret eval(Fn f, Ret v) + { + return f(v); + } + + // for testing variadic templates and trailing return types + template auto sum(V first) -> V + { + return first; + } + template auto sum(V first, Args... rest) -> V + { + return first + sum(rest...); + } +} +' + +# Test code for whether the C++ compiler supports C++11 (body of main) +ac_cxx_conftest_cxx11_main=' +{ + // Test auto and decltype + auto a1 = 6538; + auto a2 = 48573953.4; + auto a3 = "String literal"; + + int total = 0; + for (auto i = a3; *i; ++i) { total += *i; } + + decltype(a2) a4 = 34895.034; +} +{ + // Test constexpr + short sa[cxx11test::get_val()] = { 0 }; +} +{ + // Test initializer lists + cxx11test::testinit il = { 4323, 435234.23544 }; +} +{ + // Test range-based for + int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, + 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; + for (auto &x : array) { x += 23; } +} +{ + // Test lambda expressions + using cxx11test::eval; + assert (eval ([](int x) { return x*2; }, 21) == 42); + double d = 2.0; + assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0); + assert (d == 5.0); + assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0); + assert (d == 5.0); +} +{ + // Test use of variadic templates + using cxx11test::sum; + auto a = sum(1); + auto b = sum(1, 2); + auto c = sum(1.0, 2.0, 3.0); +} +{ + // Test constructor delegation + cxx11test::delegate d1; + cxx11test::delegate d2(); + cxx11test::delegate d3(45); +} +{ + // Test override and final + cxx11test::overridden o1(55464); +} +{ + // Test nullptr + char *c = nullptr; +} +{ + // Test template brackets + test_template<::test_template> v(test_template(12)); +} +{ + // Unicode literals + char const *utf8 = u8"UTF-8 string \u2500"; + char16_t const *utf16 = u"UTF-8 string \u2500"; + char32_t const *utf32 = U"UTF-32 string \u2500"; +} +' + +# Test code for whether the C compiler supports C++11 (complete). +ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals} +${ac_cxx_conftest_cxx11_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_cxx_conftest_cxx98_main} + ${ac_cxx_conftest_cxx11_main} + return ok; +} +" + +# Test code for whether the C compiler supports C++98 (complete). +ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals} +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_cxx_conftest_cxx98_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 + +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ +struct buf { int x; }; +struct buf * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not \xHH hex character constants. + These do not provoke an error unfortunately, instead are silently treated + as an "x". The following induces an error, until -std is added to get + proper ANSI mode. Curiously \x00 != x always comes out true, for an + array size at least. It is necessary to write \x00 == 0 to get something + that is true only with -std. */ +int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) '\''x'\'' +int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int), + int, int);' + +# Test code for whether the C compiler supports C89 (body of main). +ac_c_conftest_c89_main=' +ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); +' + +# Test code for whether the C compiler supports C99 (global declarations) +ac_c_conftest_c99_globals=' +// Does the compiler advertise C99 conformance? +#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L +# error "Compiler does not advertise C99 conformance" +#endif + +#include +extern int puts (const char *); +extern int printf (const char *, ...); +extern int dprintf (int, const char *, ...); +extern void *malloc (size_t); + +// 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. +#define debug(...) dprintf (2, __VA_ARGS__) +#define showlist(...) puts (#__VA_ARGS__) +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) +static void +test_varargs_macros (void) +{ + int x = 1234; + int y = 5678; + debug ("Flag"); + debug ("X = %d\n", x); + showlist (The first, second, and third items.); + report (x>y, "x is %d but y is %d", x, y); +} + +// Check long long types. +#define BIG64 18446744073709551615ull +#define BIG32 4294967295ul +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) +#if !BIG_OK + #error "your preprocessor is broken" +#endif +#if BIG_OK +#else + #error "your preprocessor is broken" +#endif +static long long int bignum = -9223372036854775807LL; +static unsigned long long int ubignum = BIG64; + +struct incomplete_array +{ + int datasize; + double data[]; +}; + +struct named_init { + int number; + const wchar_t *name; + double average; +}; + +typedef const char *ccp; + +static inline int +test_restrict (ccp restrict text) +{ + // See if C++-style comments work. + // Iterate through items via the restricted pointer. + // Also check for declarations in for loops. + for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) + continue; + return 0; +} + +// Check varargs and va_copy. +static bool +test_varargs (const char *format, ...) +{ + va_list args; + va_start (args, format); + va_list args_copy; + va_copy (args_copy, args); + + const char *str = ""; + int number = 0; + float fnumber = 0; + + while (*format) + { + switch (*format++) + { + case '\''s'\'': // string + str = va_arg (args_copy, const char *); + break; + case '\''d'\'': // int + number = va_arg (args_copy, int); + break; + case '\''f'\'': // float + fnumber = va_arg (args_copy, double); + break; + default: + break; + } + } + va_end (args_copy); + va_end (args); + + return *str && number && fnumber; +} +' + +# Test code for whether the C compiler supports C99 (body of main). +ac_c_conftest_c99_main=' + // Check bool. + _Bool success = false; + success |= (argc != 0); + + // Check restrict. + if (test_restrict ("String literal") == 0) + success = true; + 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)); + ia->datasize = 10; + for (int i = 0; i < ia->datasize; ++i) + ia->data[i] = i * 1.234; + + // Check named initializers. + struct named_init ni = { + .number = 34, + .name = L"Test wide string", + .average = 543.34343, + }; + + ni.number = 58; + + int dynamic_array[ni.number]; + dynamic_array[0] = argv[0][0]; + dynamic_array[ni.number - 1] = 543; + + // work around unused variable warnings + ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' + || dynamic_array[ni.number - 1] != 543); +' + +# Test code for whether the C compiler supports C11 (global declarations) +ac_c_conftest_c11_globals=' +// Does the compiler advertise C11 conformance? +#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L +# error "Compiler does not advertise C11 conformance" +#endif + +// Check _Alignas. +char _Alignas (double) aligned_as_double; +char _Alignas (0) no_special_alignment; +extern char aligned_as_int; +char _Alignas (0) _Alignas (int) aligned_as_int; + +// Check _Alignof. +enum +{ + int_alignment = _Alignof (int), + int_array_alignment = _Alignof (int[100]), + char_alignment = _Alignof (char) +}; +_Static_assert (0 < -_Alignof (int), "_Alignof is signed"); + +// Check _Noreturn. +int _Noreturn does_not_return (void) { for (;;) continue; } + +// Check _Static_assert. +struct test_static_assert +{ + int x; + _Static_assert (sizeof (int) <= sizeof (long int), + "_Static_assert does not work in struct"); + long int y; +}; + +// Check UTF-8 literals. +#define u8 syntax error! +char const utf8_literal[] = u8"happens to be ASCII" "another string"; + +// Check duplicate typedefs. +typedef long *long_ptr; +typedef long int *long_ptr; +typedef long_ptr long_ptr; + +// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. +struct anonymous +{ + union { + struct { int i; int j; }; + struct { int k; long int l; } w; + }; + int m; +} v1; +' + +# Test code for whether the C compiler supports C11 (body of main). +ac_c_conftest_c11_main=' + _Static_assert ((offsetof (struct anonymous, i) + == offsetof (struct anonymous, w.k)), + "Anonymous union alignment botch"); + v1.i = 2; + v1.w.k = 5; + ok |= v1.i != 5; +' + +# Test code for whether the C compiler supports C11 (complete). +ac_c_conftest_c11_program="${ac_c_conftest_c89_globals} +${ac_c_conftest_c99_globals} +${ac_c_conftest_c11_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + ${ac_c_conftest_c99_main} + ${ac_c_conftest_c11_main} + return ok; +} +" + +# Test code for whether the C compiler supports C99 (complete). +ac_c_conftest_c99_program="${ac_c_conftest_c89_globals} +${ac_c_conftest_c99_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + ${ac_c_conftest_c99_main} + return ok; +} +" + +# Test code for whether the C compiler supports C89 (complete). +ac_c_conftest_c89_program="${ac_c_conftest_c89_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + return ok; +} +" + +as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" +as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" +as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" +as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H" +as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H" +as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H" +as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H" +as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H" +as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H" +as_fn_append ac_header_c_list " sys/time.h sys_time_h HAVE_SYS_TIME_H" +as_fn_append ac_header_c_list " sys/param.h sys_param_h HAVE_SYS_PARAM_H" +as_fn_append ac_func_c_list " getpagesize HAVE_GETPAGESIZE" + +# Auxiliary files required by this configure script. +ac_aux_files="config.guess config.sub" + +# Locations in which to look for auxiliary files. +ac_aux_dir_candidates="${srcdir}/scripts/autoconf" + +# Search for a directory containing all of the required auxiliary files, +# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates. +# If we don't find one directory that contains all the files we need, +# we report the set of missing files from the *first* directory in +# $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 +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in $ac_aux_dir_candidates +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + as_found=: + + 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 + do + # As a special case, if "install-sh" is required, that requirement + # can be satisfied by any of "install-sh", "install.sh", or "shtool", + # and $ac_install_sh is set appropriately for whichever one is found. + 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 + 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 + 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 + ac_install_sh="${as_dir}shtool install -c" + else + ac_aux_dir_found=no + if $ac_first_candidate; then + ac_missing_aux_files="${ac_missing_aux_files} install-sh" + else + break + fi + fi + else + if test -f "${as_dir}${ac_aux}"; then + 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 + ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}" + else + break + fi + fi + fi + done + if test "$ac_aux_dir_found" = yes; then + ac_aux_dir="$as_dir" break fi + ac_first_candidate=false + + as_found=false done -if test -z "$ac_aux_dir"; then - as_fn_error $? "cannot find install-sh, install.sh, or shtool in scripts/autoconf \"$srcdir\"/scripts/autoconf" "$LINENO" 5 +IFS=$as_save_IFS +if $as_found +then : + +else $as_nop + as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 fi + # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. -ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. -ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. -ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. +if test -f "${ac_aux_dir}config.guess"; then + ac_config_guess="$SHELL ${ac_aux_dir}config.guess" +fi +if test -f "${ac_aux_dir}config.sub"; then + ac_config_sub="$SHELL ${ac_aux_dir}config.sub" +fi +if test -f "$ac_aux_dir/configure"; then + ac_configure="$SHELL ${ac_aux_dir}configure" +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + 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;} + 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;} + 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` + 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;} + 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;} + 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;} + 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=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + 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;} + as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file' + and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +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 + + # Check what host we are running on. # If a target is not suggested, we use this one. # Note that what we call a target, Autoconf calls a host. -# Make sure we can run config.sub. -$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || - as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 -$as_echo_n "checking build system type... " >&6; } -if ${ac_cv_build+:} false; then : - $as_echo_n "(cached) " >&6 -else + + + # Make sure we can run config.sub. +$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 "checking build system type... " >&6; } +if test ${ac_cv_build+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_build_alias=$build_alias test "x$ac_build_alias" = x && - ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` + ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 -ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 +ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 -$as_echo "$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;; @@ -2821,21 +3401,22 @@ IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 -$as_echo_n "checking host system type... " >&6; } -if ${ac_cv_host+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else - ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 + ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` || + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5 fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 -$as_echo "$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;; @@ -2872,8 +3453,8 @@ target_grub2_version=$default_grub2_version # Don't strip the version of the target yet, it might be # useful on some systems. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AROS style target" >&5 -$as_echo_n "checking for AROS style target... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AROS style target" >&5 +printf %s "checking for AROS style target... " >&6; } if test "$target" = "NONE" ; then target=$host_os-$host_cpu @@ -2882,27 +3463,27 @@ else target=$host_os-$host_cpu fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target" >&5 -$as_echo "$target" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target" >&5 +printf "%s\n" "$target" >&6; } if test "$host_os" = "mingw32" ; then PWDCMD="pwd -W" fi # Don't know where else to put this... -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking building AROS in" >&5 -$as_echo_n "checking building AROS in... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking building AROS in" >&5 +printf %s "checking building AROS in... " >&6; } AROS_BUILDDIR=`${PWDCMD-pwd}` AROS_BUILDDIR_UNIX=${PWD} -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_BUILDDIR" >&5 -$as_echo "$AROS_BUILDDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_BUILDDIR" >&5 +printf "%s\n" "$AROS_BUILDDIR" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS source in" >&5 -$as_echo_n "checking AROS source in... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking AROS source in" >&5 +printf %s "checking AROS source in... " >&6; } srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}` SRCDIR=${srcpwd} -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SRCDIR" >&5 -$as_echo "$SRCDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SRCDIR" >&5 +printf "%s\n" "$SRCDIR" >&6; } # Parse the target field into something useful. @@ -2911,23 +3492,24 @@ target_cpu=`echo $target | sed 's/^\([^-].*\)-\(.*\)$/\2/'` # Some debug output, to be removed again. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target system (debug output)" >&5 -$as_echo_n "checking for target system (debug output)... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_os" >&5 -$as_echo "$target_os" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target cpu (debug output)" >&5 -$as_echo_n "checking for target cpu (debug output)... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_cpu" >&5 -$as_echo "$target_cpu" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target system (debug output)" >&5 +printf %s "checking for target system (debug output)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_os" >&5 +printf "%s\n" "$target_os" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target cpu (debug output)" >&5 +printf %s "checking for target cpu (debug output)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_cpu" >&5 +printf "%s\n" "$target_cpu" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which prefs set to use" >&5 -$as_echo_n "checking which prefs set to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which prefs set to use" >&5 +printf %s "checking which prefs set to use... " >&6; } # Check whether --with-aros-prefs was given. -if test "${with_aros_prefs+set}" = set; then : +if test ${with_aros_prefs+y} +then : withval=$with_aros_prefs; config_prefs_set="$withval" -else +else $as_nop config_prefs_set="" fi @@ -2936,8 +3518,8 @@ if test "$config_prefs_set" != "" ; then else msg_result="default" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } aros_dist_name=AROS aros_dist_version=ABIv1 @@ -2958,9 +3540,10 @@ HOST_WANTS_DLOPEN= default_c_compilers="gcc clang cc" # Check whether --with-c-compiler was given. -if test "${with_c_compiler+set}" = set; then : +if test ${with_c_compiler+y} +then : withval=$with_c_compiler; use_c_compiler="$withval" -else +else $as_nop use_c_compiler="" fi @@ -2974,9 +3557,10 @@ fi default_cxx_compilers="g++ clang++ c++" # Check whether --with-cxx-compiler was given. -if test "${with_cxx_compiler+set}" = set; then : +if test ${with_cxx_compiler+y} +then : withval=$with_cxx_compiler; use_cxx_compiler="$withval" -else +else $as_nop use_cxx_compiler="" fi @@ -2992,6 +3576,12 @@ fi # Check for a compiler. # Due to a bug in autoconf check for c++ compiler first. # For mor info see, http://osdir.com/ml/bug-autoconf-gnu/2010-05/msg00001.html. + + + + + + ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -3006,11 +3596,12 @@ if test -z "$CXX"; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CXX"; then ac_cv_prog_CXX="$CXX" # Let the user override the test. else @@ -3018,11 +3609,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - $as_echo "$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 @@ -3033,11 +3628,11 @@ fi fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -$as_echo "$CXX" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf "%s\n" "$CXX" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -3050,11 +3645,12 @@ 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ac_ct_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$ac_ct_CXX"; then ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. else @@ -3062,11 +3658,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" - $as_echo "$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 @@ -3077,11 +3677,11 @@ fi fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -3093,8 +3693,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$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 @@ -3104,7 +3704,7 @@ fi fi fi # Provide some information about the compiler. -$as_echo "$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; do @@ -3114,7 +3714,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$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 @@ -3124,7 +3724,7 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done @@ -3132,7 +3732,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; @@ -3144,9 +3744,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. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5 -$as_echo_n "checking whether the C++ compiler works... " >&6; } -ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +{ 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[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" @@ -3167,11 +3767,12 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : + 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'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, @@ -3188,7 +3789,7 @@ do # certainly right. break;; *.* ) - if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi @@ -3204,44 +3805,46 @@ do done test "$ac_cv_exeext" = no && ac_cv_exeext= -else +else $as_nop ac_file='' fi -if test -z "$ac_file"; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -$as_echo "$as_me: failed program was:" >&5 +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 sed 's/^/| /' conftest.$ac_ext >&5 -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5 -$as_echo_n "checking for C++ compiler default output file name... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 -$as_echo "$ac_file" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } +fi +{ 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; } 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 -$as_echo_n "checking for suffix of executables... " >&6; } +{ 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 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : + 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) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with @@ -3255,15 +3858,15 @@ for ac_file in conftest.exe conftest conftest.*; do * ) break;; esac done -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +else $as_nop + { { 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; } fi rm -f conftest conftest$ac_cv_exeext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 -$as_echo "$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 @@ -3272,7 +3875,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int -main () +main (void) { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; @@ -3284,8 +3887,8 @@ _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. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 -$as_echo_n "checking whether we are cross compiling... " >&6; } +{ 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" case "(($ac_try" in @@ -3293,10 +3896,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - $as_echo "$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 @@ -3304,39 +3907,40 @@ $as_echo "$ac_try_echo"; } >&5 *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? - $as_echo "$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 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "cannot run C++ compiled programs. + { { 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 -$as_echo "$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.out ac_clean_files=$ac_clean_files_save -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 -$as_echo_n "checking for suffix of object files... " >&6; } -if ${ac_cv_objext+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; @@ -3350,342 +3954,46 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : - for ac_file in conftest.o conftest.obj conftest.*; do - test -f "$ac_file" || continue; - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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; } -fi -rm -f conftest.$ac_cv_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 -$as_echo "$ac_cv_objext" >&6; } -OBJEXT=$ac_cv_objext -ac_objext=$OBJEXT -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 -$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } -if ${ac_cv_cxx_compiler_gnu+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_compiler_gnu=yes -else - ac_compiler_gnu=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_cxx_compiler_gnu=$ac_compiler_gnu - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } -if test $ac_compiler_gnu = yes; then - GXX=yes -else - GXX= -fi -ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 -$as_echo_n "checking whether $CXX accepts -g... " >&6; } -if ${ac_cv_prog_cxx_g+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_save_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - ac_cv_prog_cxx_g=no - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -else - CXXFLAGS="" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - -else - ac_cxx_werror_flag=$ac_save_cxx_werror_flag - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_cxx_werror_flag=$ac_save_cxx_werror_flag -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -$as_echo "$ac_cv_prog_cxx_g" >&6; } -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi -ac_ext=c -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 - -CXX_BASE=$CXX -# Extract the first word of "$CXX", so it can be a program name with args. -set dummy $CXX; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else - case $CXX in - [\\/]* | ?:[\\/]*) - ac_cv_path_CXX="$CXX" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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_CXX="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CXX=$ac_cv_path_CXX -if test -n "$CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -$as_echo "$CXX" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -ac_ext=c -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 -if test -n "$ac_tool_prefix"; then - for ac_prog in ${host_c_compilers} - 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CC+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$CC"; then - ac_cv_prog_CC="$CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -CC=$ac_cv_prog_CC -if test -n "$CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -$as_echo "$CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$CC" && break - done -fi -if test -z "$CC"; then - ac_ct_CC=$CC - for ac_prog in ${host_c_compilers} -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ac_ct_CC+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_CC"; then - ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_CC=$ac_cv_prog_ac_ct_CC -if test -n "$ac_ct_CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -$as_echo "$ac_ct_CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$ac_ct_CC" && break -done - - if test "x$ac_ct_CC" = x; then - CC="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - CC=$ac_ct_CC - fi -fi - - -test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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. -$as_echo "$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; do - { { ac_try="$ac_compiler $ac_option >&5" -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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compiler $ac_option >&5") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - sed '10a\ -... rest of stderr output deleted ... - 10q' conftest.err >conftest.er1 - cat conftest.er1 >&5 - fi - rm -f conftest.er1 conftest.err - $as_echo "$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 + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac done +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 -$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } -if ${ac_cv_c_compiler_gnu+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ { 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; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ 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 "checking whether the compiler supports GNU C++... " >&6; } +if test ${ac_cv_cxx_compiler_gnu+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { #ifndef __GNUC__ choke me @@ -3695,190 +4003,201 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_cxx_try_compile "$LINENO" +then : ac_compiler_gnu=yes -else +else $as_nop ac_compiler_gnu=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_c_compiler_gnu=$ac_compiler_gnu +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 -$as_echo "$ac_cv_c_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 - GCC=yes + GXX=yes else - GCC= + GXX= fi -ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 -$as_echo_n "checking whether $CC accepts -g... " >&6; } -if ${ac_cv_prog_cc_g+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_save_c_werror_flag=$ac_c_werror_flag - ac_c_werror_flag=yes - ac_cv_prog_cc_g=no - CFLAGS="-g" +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 "checking whether $CXX accepts -g... " >&6; } +if test ${ac_cv_prog_cxx_g+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes -else - CFLAGS="" +if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_g=yes +else $as_nop + CXXFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_cxx_try_compile "$LINENO" +then : -else - ac_c_werror_flag=$ac_save_c_werror_flag - CFLAGS="-g" +else $as_nop + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes +if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_g=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_c_werror_flag=$ac_save_c_werror_flag +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 -$as_echo "$ac_cv_prog_cc_g" >&6; } -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O2" +{ 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 + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" else - CFLAGS="-g" + CXXFLAGS="-g" fi else - if test "$GCC" = yes; then - CFLAGS="-O2" + if test "$GXX" = yes; then + CXXFLAGS="-O2" else - CFLAGS= + CXXFLAGS= fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if ${ac_cv_prog_cc_c89+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_prog_cc_c89=no -ac_save_CC=$CC +ac_prog_cxx_stdcxx=no +if test x$ac_prog_cxx_stdcxx = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5 +printf %s "checking for $CXX option to enable C++11 features... " >&6; } +if test ${ac_cv_prog_cxx_11+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cxx_11=no +ac_save_CXX=$CXX cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -struct stat; -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv; -int -main () -{ -return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; - ; - return 0; -} +$ac_cxx_conftest_cxx11_program _ACEOF -for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA do - CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_c89=$ac_arg + CXX="$ac_save_CXX $ac_arg" + if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_cxx11=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext - test "x$ac_cv_prog_cc_c89" != "xno" && break +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cxx_cxx11" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC - +CXX=$ac_save_CXX +fi + +if test "x$ac_cv_prog_cxx_cxx11" = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf "%s\n" "unsupported" >&6; } +else $as_nop + if test "x$ac_cv_prog_cxx_cxx11" = x +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf "%s\n" "none needed" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5 +printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; } + CXX="$CXX $ac_cv_prog_cxx_cxx11" +fi + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 + ac_prog_cxx_stdcxx=cxx11 +fi +fi +if test x$ac_prog_cxx_stdcxx = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5 +printf %s "checking for $CXX option to enable C++98 features... " >&6; } +if test ${ac_cv_prog_cxx_98+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cxx_98=no +ac_save_CXX=$CXX +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_cxx_conftest_cxx98_program +_ACEOF +for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA +do + CXX="$ac_save_CXX $ac_arg" + if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_cxx98=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cxx_cxx98" != "xno" && break +done +rm -f conftest.$ac_ext +CXX=$ac_save_CXX fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c89" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c89" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c89" != xno; then : +if test "x$ac_cv_prog_cxx_cxx98" = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf "%s\n" "unsupported" >&6; } +else $as_nop + if test "x$ac_cv_prog_cxx_cxx98" = x +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf "%s\n" "none needed" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5 +printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; } + CXX="$CXX $ac_cv_prog_cxx_cxx98" +fi + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98 + ac_prog_cxx_stdcxx=cxx98 +fi fi ac_ext=c @@ -3887,517 +4206,692 @@ 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 -CC_BASE=$CC -ac_ext=c -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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -$as_echo_n "checking how to run the C preprocessor... " >&6; } -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - if ${ac_cv_prog_CPP+:} false; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes +CXX_BASE=$CXX +# Extract the first word of "$CXX", so it can be a program name with args. +set dummy $CXX; ac_word=$2 +{ 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_CXX+y} +then : + printf %s "(cached) " >&6 +else $as_nop + case $CXX in + [\\/]* | ?:[\\/]*) + ac_cv_path_CXX="$CXX" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_CXX="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS -else - # Broken: fails on valid input. -continue + ;; +esac fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue +CXX=$ac_cv_path_CXX +if test -n "$CXX"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf "%s\n" "$CXX" >&6; } else - # Passes both tests. -ac_preproc_ok=: -break + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -rm -f conftest.err conftest.i conftest.$ac_ext -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - break -fi - done - ac_cv_prog_CPP=$CPP -fi - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -$as_echo "$CPP" >&6; } -ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext + + + + + +ac_ext=c +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 +if test -n "$ac_tool_prefix"; then + for ac_prog in ${host_c_compilers} + 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 "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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 + break 2 + fi done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : + done +IFS=$as_save_IFS +fi +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; } else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -ac_ext=c -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 -CPP_BASE=$CPP -# Extract the first word of "$CC", so it can be a program name with args. -set dummy $CC; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_CC+:} false; then : - $as_echo_n "(cached) " >&6 + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in ${host_c_compilers} +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 "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_ac_ct_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else - case $CC in - [\\/]* | ?:[\\/]*) - ac_cv_path_CC="$CC" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_CC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + 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 break 2 fi done done IFS=$as_save_IFS - ;; -esac fi -CC=$ac_cv_path_CC -if test -n "$CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -$as_echo "$CC" >&6; } +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; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -aros_host_def_cc="$CC" - case $ac_cv_prog_cc_stdc in #( - no) : - ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #( - *) : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5 -$as_echo_n "checking for $CC option to accept ISO C99... " >&6; } -if ${ac_cv_prog_cc_c99+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_prog_cc_c99=no -ac_save_CC=$CC -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include -#include + test -n "$ac_ct_CC" && break +done -// Check varargs macros. These examples are taken from C99 6.10.3.5. -#define debug(...) fprintf (stderr, __VA_ARGS__) -#define showlist(...) puts (#__VA_ARGS__) -#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) -static void -test_varargs_macros (void) -{ - int x = 1234; - int y = 5678; - debug ("Flag"); - debug ("X = %d\n", x); - showlist (The first, second, and third items.); - report (x>y, "x is %d but y is %d", x, y); -} + if test "x$ac_ct_CC" = x; then + CC="" + 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;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi -// Check long long types. -#define BIG64 18446744073709551615ull -#define BIG32 4294967295ul -#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) -#if !BIG_OK - your preprocessor is broken; -#endif -#if BIG_OK -#else - your preprocessor is broken; -#endif -static long long int bignum = -9223372036854775807LL; -static unsigned long long int ubignum = BIG64; -struct incomplete_array -{ - int datasize; - double data[]; -}; +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; } -struct named_init { - int number; - const wchar_t *name; - double average; -}; +# Provide some information about the compiler. +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 + { { ac_try="$ac_compiler $ac_option >&5" +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 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done -typedef const char *ccp; +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ -static inline int -test_restrict (ccp restrict text) +int +main (void) { - // See if C++-style comments work. - // Iterate through items via the restricted pointer. - // Also check for declarations in for loops. - for (unsigned int i = 0; *(text+i) != '\0'; ++i) - continue; +#ifndef __GNUC__ + choke me +#endif + + ; return 0; } +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_compiler_gnu=yes +else $as_nop + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu -// Check varargs and va_copy. -static void -test_varargs (const char *format, ...) -{ - va_list args; - va_start (args, format); - va_list args_copy; - va_copy (args_copy, args); - - const char *str; - int number; - float fnumber; +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; } +ac_compiler_gnu=$ac_cv_c_compiler_gnu - while (*format) - { - switch (*format++) - { - case 's': // string - str = va_arg (args_copy, const char *); - break; - case 'd': // int - number = va_arg (args_copy, int); - break; - case 'f': // float - fnumber = va_arg (args_copy, double); - break; - default: - break; - } - } - va_end (args_copy); - va_end (args); -} +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +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 "checking whether $CC accepts -g... " >&6; } +if test ${ac_cv_prog_cc_g+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ int -main () +main (void) { - // Check bool. - _Bool success = false; - - // Check restrict. - if (test_restrict ("String literal") == 0) - success = true; - char *restrict newvar = "Another string"; - - // Check varargs. - test_varargs ("s, d' f .", "string", 65, 34.234); - test_varargs_macros (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +else $as_nop + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ - // Check flexible array members. - struct incomplete_array *ia = - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); - ia->datasize = 10; - for (int i = 0; i < ia->datasize; ++i) - ia->data[i] = i * 1.234; +int +main (void) +{ - // Check named initializers. - struct named_init ni = { - .number = 34, - .name = L"Test wide string", - .average = 543.34343, - }; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : - ni.number = 58; +else $as_nop + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ - int dynamic_array[ni.number]; - dynamic_array[ni.number - 1] = 543; +int +main (void) +{ - // work around unused variable warnings - return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' - || dynamic_array[ni.number - 1] != 543); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +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; } +if test $ac_test_CFLAGS; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +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 "checking for $CC option to enable C11 features... " >&6; } +if test ${ac_cv_prog_cc_c11+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cc_c11=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c11_program +_ACEOF +for ac_arg in '' -std=gnu11 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c11=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c11" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC +fi - ; - return 0; -} +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; } +else $as_nop + 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; } +else $as_nop + { 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" +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 + ac_prog_cc_stdc=c11 +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 "checking for $CC option to enable C99 features... " >&6; } +if test ${ac_cv_prog_cc_c99+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cc_c99=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c99_program _ACEOF -for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99 +for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= do CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : + if ac_fn_c_try_compile "$LINENO" +then : ac_cv_prog_cc_c99=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext +rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC +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; } +else $as_nop + 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; } +else $as_nop + { 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" fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c99" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c99" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 -$as_echo "$ac_cv_prog_cc_c99" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c99" != xno; then : ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 -else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if ${ac_cv_prog_cc_c89+:} false; then : - $as_echo_n "(cached) " >&6 -else + ac_prog_cc_stdc=c99 +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 "checking for $CC option to enable C89 features... " >&6; } +if test ${ac_cv_prog_cc_c89+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -struct stat; -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv; -int -main () -{ -return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; - ; - return 0; -} +$ac_c_conftest_c89_program _ACEOF -for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : + if ac_fn_c_try_compile "$LINENO" +then : ac_cv_prog_cc_c89=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext +rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC +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; } +else $as_nop + 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; } +else $as_nop + { 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" fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c89" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c89" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c89" != xno; then : ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 + ac_prog_cc_stdc=c89 +fi +fi + +ac_ext=c +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 + +CC_BASE=$CC +ac_ext=c +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 "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if test ${ac_cv_prog_CPP+y} +then : + printf %s "(cached) " >&6 +else $as_nop + # Double quotes because $CC needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + +else $as_nop + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + # Broken: success on invalid input. +continue +else $as_nop + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok +then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP else - ac_cv_prog_cc_stdc=no + ac_cv_prog_CPP=$CPP +fi +{ 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 + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + +else $as_nop + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + # Broken: success on invalid input. +continue +else $as_nop + # Passes both tests. +ac_preproc_ok=: +break fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok +then : +else $as_nop + { { 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; } fi - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5 -$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; } - if ${ac_cv_prog_cc_stdc+:} false; then : - $as_echo_n "(cached) " >&6 -fi - - case $ac_cv_prog_cc_stdc in #( - no) : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; #( - '') : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; #( - *) : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5 -$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;; + +ac_ext=c +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 + +CPP_BASE=$CPP +# 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 "checking for $ac_word... " >&6; } +if test ${ac_cv_path_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + case $CC in + [\\/]* | ?:[\\/]*) + ac_cv_path_CC="$CC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_CC="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; esac +fi +CC=$ac_cv_path_CC +if test -n "$CC"; then + { 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; } +fi + + +aros_host_def_cc="$CC" ac_ext=c 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -$as_echo_n "checking how to run the C preprocessor... " >&6; } +{ 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 CPP= fi if test -z "$CPP"; then - if ${ac_cv_prog_CPP+:} false; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + if test ${ac_cv_prog_CPP+y} +then : + printf %s "(cached) " >&6 +else $as_nop + # Double quotes because $CC needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif +#include Syntax error _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : -else +else $as_nop # Broken: fails on valid input. continue fi @@ -4409,10 +4903,11 @@ rm -f conftest.err conftest.i conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # Broken: success on invalid input. continue -else +else $as_nop # Passes both tests. ac_preproc_ok=: break @@ -4422,7 +4917,8 @@ rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : +if $ac_preproc_ok +then : break fi @@ -4434,29 +4930,24 @@ fi else ac_cv_prog_CPP=$CPP fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -$as_echo "$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 # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif +#include Syntax error _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : -else +else $as_nop # Broken: fails on valid input. continue fi @@ -4468,10 +4959,11 @@ rm -f conftest.err conftest.i conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # Broken: success on invalid input. continue -else +else $as_nop # Passes both tests. ac_preproc_ok=: break @@ -4481,11 +4973,12 @@ rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : +if $ac_preproc_ok +then : -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +else $as_nop + { { 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; } fi @@ -4498,8 +4991,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu # detect the compiler version -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which toolchain family ${CC_BASE} belongs to" >&5 -$as_echo_n "checking which toolchain family ${CC_BASE} belongs to... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which toolchain family ${CC_BASE} belongs to" >&5 +printf %s "checking which toolchain family ${CC_BASE} belongs to... " >&6; } HOST_COMPILER_VERSION=`"$CC" --version 2>/dev/null` if test x"$HOST_COMPILER_VERSION" = "x"; then HOST_COMPILER_VERSION=`"$CC" --qversion 2>/dev/null` @@ -4535,19 +5028,20 @@ fi if test x"$HOST_TOOLCHAIN_FAMILY" = "x"; then HOST_TOOLCHAIN_FAMILY=unknown fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOST_TOOLCHAIN_FAMILY" >&5 -$as_echo "$HOST_TOOLCHAIN_FAMILY" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HOST_TOOLCHAIN_FAMILY" >&5 +printf "%s\n" "$HOST_TOOLCHAIN_FAMILY" >&6; } # Check for a compatible awk for ac_prog in gawk nawk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_AWK+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else @@ -4555,11 +5049,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" - $as_echo "$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 @@ -4570,11 +5068,11 @@ fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 -$as_echo "$AWK" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +printf "%s\n" "$AWK" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4593,11 +5091,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mmake", so it can be a program name with args. set dummy mmake; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MMAKE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MMAKE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MMAKE"; then ac_cv_prog_MMAKE="$MMAKE" # Let the user override the test. else @@ -4605,11 +5104,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MMAKE="mmake " - $as_echo "$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 @@ -4620,11 +5123,11 @@ fi fi MMAKE=$ac_cv_prog_MMAKE if test -n "$MMAKE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MMAKE" >&5 -$as_echo "$MMAKE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MMAKE" >&5 +printf "%s\n" "$MMAKE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4642,11 +5145,12 @@ if test "$HOST_TOOLCHAIN_FAMILY" = "llvm"; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_base_lld_name+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_base_lld_name+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$base_lld_name"; then ac_cv_prog_base_lld_name="$base_lld_name" # Let the user override the test. else @@ -4654,11 +5158,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_base_lld_name="$ac_prog" - $as_echo "$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 @@ -4669,11 +5177,11 @@ fi fi base_lld_name=$ac_cv_prog_base_lld_name if test -n "$base_lld_name"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $base_lld_name" >&5 -$as_echo "$base_lld_name" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $base_lld_name" >&5 +printf "%s\n" "$base_lld_name" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4684,11 +5192,12 @@ done else # Extract the first word of "$base_ld_name", so it can be a program name with args. set dummy $base_ld_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_LD_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_LD_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$LD_BASE"; then ac_cv_prog_LD_BASE="$LD_BASE" # Let the user override the test. else @@ -4696,11 +5205,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_LD_BASE="" - $as_echo "$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 @@ -4711,11 +5224,11 @@ fi fi LD_BASE=$ac_cv_prog_LD_BASE if test -n "$LD_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_BASE" >&5 -$as_echo "$LD_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD_BASE" >&5 +printf "%s\n" "$LD_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4730,11 +5243,12 @@ if test "$GCC" = "yes"; then aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. set dummy `basename $aros_gcc_ld`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. @@ -4744,11 +5258,15 @@ else for as_dir in `dirname $aros_gcc_ld` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4760,11 +5278,11 @@ esac fi aros_host_ld=$ac_cv_path_aros_host_ld if test -n "$aros_host_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 -$as_echo "$aros_host_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +printf "%s\n" "$aros_host_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4774,11 +5292,12 @@ if test "$aros_host_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. @@ -4788,11 +5307,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4804,11 +5327,11 @@ esac fi aros_host_ld=$ac_cv_path_aros_host_ld if test -n "$aros_host_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 -$as_echo "$aros_host_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +printf "%s\n" "$aros_host_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4851,11 +5374,12 @@ for ac_prog in aclocal aclocal19 aclocal-1.9 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_aclocal+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_aclocal+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_aclocal"; then ac_cv_prog_aros_host_aclocal="$aros_host_aclocal" # Let the user override the test. else @@ -4863,11 +5387,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_aclocal="$ac_prog" - $as_echo "$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 @@ -4878,11 +5406,11 @@ fi fi aros_host_aclocal=$ac_cv_prog_aros_host_aclocal if test -n "$aros_host_aclocal"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_aclocal" >&5 -$as_echo "$aros_host_aclocal" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_aclocal" >&5 +printf "%s\n" "$aros_host_aclocal" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4893,11 +5421,12 @@ for ac_prog in autoconf autoconf259 autoconf253 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_autoconf+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_autoconf+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_autoconf"; then ac_cv_prog_aros_host_autoconf="$aros_host_autoconf" # Let the user override the test. else @@ -4905,11 +5434,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_autoconf="$ac_prog" - $as_echo "$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 @@ -4920,11 +5453,11 @@ fi fi aros_host_autoconf=$ac_cv_prog_aros_host_autoconf if test -n "$aros_host_autoconf"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoconf" >&5 -$as_echo "$aros_host_autoconf" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoconf" >&5 +printf "%s\n" "$aros_host_autoconf" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4935,11 +5468,12 @@ for ac_prog in autoheader autoheader259 autoheader253 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_autoheader+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_autoheader+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_autoheader"; then ac_cv_prog_aros_host_autoheader="$aros_host_autoheader" # Let the user override the test. else @@ -4947,11 +5481,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_autoheader="$ac_prog" - $as_echo "$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 @@ -4962,11 +5500,11 @@ fi fi aros_host_autoheader=$ac_cv_prog_aros_host_autoheader if test -n "$aros_host_autoheader"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoheader" >&5 -$as_echo "$aros_host_autoheader" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoheader" >&5 +printf "%s\n" "$aros_host_autoheader" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4977,11 +5515,12 @@ for ac_prog in automake automake19 automake-1.9 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_automake+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_automake+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_automake"; then ac_cv_prog_aros_host_automake="$aros_host_automake" # Let the user override the test. else @@ -4989,11 +5528,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_automake="$ac_prog" - $as_echo "$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 @@ -5004,11 +5547,11 @@ fi fi aros_host_automake=$ac_cv_prog_aros_host_automake if test -n "$aros_host_automake"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_automake" >&5 -$as_echo "$aros_host_automake" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_automake" >&5 +printf "%s\n" "$aros_host_automake" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5079,8 +5622,8 @@ case "$host_os" in aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5109,8 +5652,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="arm" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5137,16 +5680,17 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} ;; darwin*) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for macOS SDK files" >&5 -$as_echo_n "checking for macOS SDK files... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for macOS SDK files" >&5 +printf %s "checking for macOS SDK files... " >&6; } LOC=$( xcode-select -p ) - if test $? != 0; then : + if test $? != 0 +then : as_fn_error $? "XCode incorrectly configured! please run 'xcode-select --install' before re-running configure" "$LINENO" 5 fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LOC" >&5 -$as_echo "$LOC" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LOC" >&5 +printf "%s\n" "$LOC" >&6; } aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" aros_host_arch="darwin" host_cc_elf=no @@ -5165,8 +5709,8 @@ $as_echo "$LOC" >&6; } aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5187,8 +5731,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} aros_host_cpu="x86_64" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5206,8 +5750,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="m68k" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5223,8 +5767,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="i386" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5241,8 +5785,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="sparc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5270,8 +5814,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5290,8 +5834,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="i386" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5310,11 +5854,11 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} case "$host_cpu" in *i?86*) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Windows native gcc target" >&5 -$as_echo_n "checking for Windows native gcc target... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Windows native gcc target" >&5 +printf %s "checking for Windows native gcc target... " >&6; } host_cpu=`gcc -dumpmachine` - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_cpu" >&5 -$as_echo "$host_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $host_cpu" >&5 +printf "%s\n" "$host_cpu" >&6; } ;; esac @@ -5334,8 +5878,8 @@ $as_echo "$host_cpu" >&6; } ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5348,11 +5892,12 @@ esac base_ar_name=${HOST_TOOLCHAIN_PREFIX}ar${HOST_TOOLCHAIN_SUFFIX} # Extract the first word of "$base_ar_name", so it can be a program name with args. set dummy $base_ar_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_AR_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$AR_BASE"; then ac_cv_prog_AR_BASE="$AR_BASE" # Let the user override the test. else @@ -5360,11 +5905,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AR_BASE="$base_ar_name " - $as_echo "$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 @@ -5375,11 +5924,11 @@ fi fi AR_BASE=$ac_cv_prog_AR_BASE if test -n "$AR_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_BASE" >&5 -$as_echo "$AR_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR_BASE" >&5 +printf "%s\n" "$AR_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5387,11 +5936,12 @@ aros_host_ar_flags="cr" aros_host_cmd_ar="$AR_BASE $aros_host_ar_flags" # Extract the first word of "$aros_host_cmd_ar", so it can be a program name with args. set dummy $aros_host_cmd_ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_plain_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_plain_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_plain_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_plain_ar="$aros_host_plain_ar" # Let the user override the test with a path. @@ -5401,11 +5951,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_plain_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_plain_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5418,11 +5972,11 @@ esac fi aros_host_plain_ar=$ac_cv_path_aros_host_plain_ar if test -n "$aros_host_plain_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_plain_ar" >&5 -$as_echo "$aros_host_plain_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_plain_ar" >&5 +printf "%s\n" "$aros_host_plain_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5440,11 +5994,12 @@ fi base_ranlib_name=${HOST_TOOLCHAIN_PREFIX}ranlib${HOST_TOOLCHAIN_SUFFIX} # Extract the first word of "$base_ranlib_name", so it can be a program name with args. set dummy $base_ranlib_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_RANLIB_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$RANLIB_BASE"; then ac_cv_prog_RANLIB_BASE="$RANLIB_BASE" # Let the user override the test. else @@ -5452,11 +6007,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RANLIB_BASE="$base_ranlib_name " - $as_echo "$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 @@ -5467,21 +6026,22 @@ fi fi RANLIB_BASE=$ac_cv_prog_RANLIB_BASE if test -n "$RANLIB_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_BASE" >&5 -$as_echo "$RANLIB_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB_BASE" >&5 +printf "%s\n" "$RANLIB_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi # Extract the first word of "$RANLIB_BASE", so it can be a program name with args. set dummy $RANLIB_BASE; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ranlib="$aros_host_ranlib" # Let the user override the test with a path. @@ -5491,11 +6051,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5508,11 +6072,11 @@ esac fi aros_host_ranlib=$ac_cv_path_aros_host_ranlib if test -n "$aros_host_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ranlib" >&5 -$as_echo "$aros_host_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ranlib" >&5 +printf "%s\n" "$aros_host_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5528,11 +6092,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_strip"; then ac_cv_prog_aros_host_strip="$aros_host_strip" # Let the user override the test. else @@ -5540,11 +6105,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_strip="strip " - $as_echo "$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 @@ -5555,11 +6124,11 @@ fi fi aros_host_strip=$ac_cv_prog_aros_host_strip if test -n "$aros_host_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_strip" >&5 -$as_echo "$aros_host_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_strip" >&5 +printf "%s\n" "$aros_host_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5576,11 +6145,12 @@ fi # Extract the first word of "rm", so it can be a program name with args. set dummy rm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_RM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_RM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$RM"; then ac_cv_prog_RM="$RM" # Let the user override the test. else @@ -5588,11 +6158,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RM="rm -rf" - $as_echo "$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 @@ -5603,11 +6177,11 @@ fi fi RM=$ac_cv_prog_RM if test -n "$RM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 -$as_echo "$RM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 +printf "%s\n" "$RM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5623,11 +6197,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "cp", so it can be a program name with args. set dummy cp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CP+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CP+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CP"; then ac_cv_prog_CP="$CP" # Let the user override the test. else @@ -5635,11 +6210,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CP="cp " - $as_echo "$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 @@ -5650,11 +6229,11 @@ fi fi CP=$ac_cv_prog_CP if test -n "$CP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 -$as_echo "$CP" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 +printf "%s\n" "$CP" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5670,11 +6249,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mv", so it can be a program name with args. set dummy mv; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MV+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MV+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MV"; then ac_cv_prog_MV="$MV" # Let the user override the test. else @@ -5682,11 +6262,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MV="mv " - $as_echo "$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 @@ -5697,11 +6281,11 @@ fi fi MV=$ac_cv_prog_MV if test -n "$MV"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 -$as_echo "$MV" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 +printf "%s\n" "$MV" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5717,11 +6301,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "echo", so it can be a program name with args. set dummy echo; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ECHO+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_ECHO+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$ECHO"; then ac_cv_prog_ECHO="$ECHO" # Let the user override the test. else @@ -5729,11 +6314,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ECHO="echo " - $as_echo "$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 @@ -5744,11 +6333,11 @@ fi fi ECHO=$ac_cv_prog_ECHO if test -n "$ECHO"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 -$as_echo "$ECHO" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 +printf "%s\n" "$ECHO" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5764,11 +6353,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mkdir", so it can be a program name with args. set dummy mkdir; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MKDIR+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MKDIR+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MKDIR"; then ac_cv_prog_MKDIR="$MKDIR" # Let the user override the test. else @@ -5776,11 +6366,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MKDIR="mkdir -p" - $as_echo "$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 @@ -5791,11 +6385,11 @@ fi fi MKDIR=$ac_cv_prog_MKDIR if test -n "$MKDIR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 -$as_echo "$MKDIR" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 +printf "%s\n" "$MKDIR" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5811,11 +6405,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "touch", so it can be a program name with args. set dummy touch; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_TOUCH+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_TOUCH+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$TOUCH"; then ac_cv_prog_TOUCH="$TOUCH" # Let the user override the test. else @@ -5823,11 +6418,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_TOUCH="touch " - $as_echo "$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 @@ -5838,11 +6437,11 @@ fi fi TOUCH=$ac_cv_prog_TOUCH if test -n "$TOUCH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 -$as_echo "$TOUCH" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 +printf "%s\n" "$TOUCH" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5858,11 +6457,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "sort", so it can be a program name with args. set dummy sort; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_SORT+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SORT+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$SORT"; then ac_cv_prog_SORT="$SORT" # Let the user override the test. else @@ -5870,11 +6470,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_SORT="sort " - $as_echo "$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 @@ -5885,11 +6489,11 @@ fi fi SORT=$ac_cv_prog_SORT if test -n "$SORT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 -$as_echo "$SORT" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 +printf "%s\n" "$SORT" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5905,11 +6509,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "uniq", so it can be a program name with args. set dummy uniq; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_UNIQ+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_UNIQ+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$UNIQ"; then ac_cv_prog_UNIQ="$UNIQ" # Let the user override the test. else @@ -5917,11 +6522,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_UNIQ="uniq " - $as_echo "$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 @@ -5932,11 +6541,11 @@ fi fi UNIQ=$ac_cv_prog_UNIQ if test -n "$UNIQ"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5 -$as_echo "$UNIQ" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5 +printf "%s\n" "$UNIQ" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5952,11 +6561,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "true", so it can be a program name with args. set dummy true; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_NOP+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_NOP+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$NOP"; then ac_cv_prog_NOP="$NOP" # Let the user override the test. else @@ -5964,11 +6574,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_NOP="true " - $as_echo "$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 @@ -5979,11 +6593,11 @@ fi fi NOP=$ac_cv_prog_NOP if test -n "$NOP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NOP" >&5 -$as_echo "$NOP" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NOP" >&5 +printf "%s\n" "$NOP" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5999,11 +6613,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "cat", so it can be a program name with args. set dummy cat; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CAT+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CAT+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CAT"; then ac_cv_prog_CAT="$CAT" # Let the user override the test. else @@ -6011,11 +6626,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CAT="cat " - $as_echo "$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 @@ -6026,11 +6645,11 @@ fi fi CAT=$ac_cv_prog_CAT if test -n "$CAT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 -$as_echo "$CAT" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 +printf "%s\n" "$CAT" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6046,11 +6665,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "bison", so it can be a program name with args. set dummy bison; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_BISON+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BISON+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$BISON"; then ac_cv_prog_BISON="$BISON" # Let the user override the test. else @@ -6058,11 +6678,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_BISON="bison " - $as_echo "$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 @@ -6073,11 +6697,11 @@ fi fi BISON=$ac_cv_prog_BISON if test -n "$BISON"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5 -$as_echo "$BISON" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5 +printf "%s\n" "$BISON" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6093,11 +6717,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "flex", so it can be a program name with args. set dummy flex; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_FLEX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_FLEX+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$FLEX"; then ac_cv_prog_FLEX="$FLEX" # Let the user override the test. else @@ -6105,11 +6730,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_FLEX="flex " - $as_echo "$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 @@ -6120,11 +6749,11 @@ fi fi FLEX=$ac_cv_prog_FLEX if test -n "$FLEX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5 -$as_echo "$FLEX" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5 +printf "%s\n" "$FLEX" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6138,18 +6767,19 @@ fi if test "$req_avail" = "no"; then as_fn_error $? "flex is required to build AROS. Please install and run configure again." "$LINENO" 5 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking version of $FLEX" >&5 -$as_echo_n "checking version of $FLEX... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking version of $FLEX" >&5 +printf %s "checking version of $FLEX... " >&6; } ax_cv_flex_version="`$FLEX --version | cut -d\" \" -f2`" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_flex_version" >&5 -$as_echo "$ax_cv_flex_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_flex_version" >&5 +printf "%s\n" "$ax_cv_flex_version" >&6; } # Extract the first word of "pngtopnm", so it can be a program name with args. set dummy pngtopnm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PNGTOPNM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PNGTOPNM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PNGTOPNM"; then ac_cv_prog_PNGTOPNM="$PNGTOPNM" # Let the user override the test. else @@ -6157,11 +6787,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PNGTOPNM="pngtopnm " - $as_echo "$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 @@ -6172,11 +6806,11 @@ fi fi PNGTOPNM=$ac_cv_prog_PNGTOPNM if test -n "$PNGTOPNM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PNGTOPNM" >&5 -$as_echo "$PNGTOPNM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PNGTOPNM" >&5 +printf "%s\n" "$PNGTOPNM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6192,11 +6826,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "ppmtoilbm", so it can be a program name with args. set dummy ppmtoilbm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PPMTOILBM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PPMTOILBM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PPMTOILBM"; then ac_cv_prog_PPMTOILBM="$PPMTOILBM" # Let the user override the test. else @@ -6204,11 +6839,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PPMTOILBM="ppmtoilbm " - $as_echo "$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 @@ -6219,11 +6858,11 @@ fi fi PPMTOILBM=$ac_cv_prog_PPMTOILBM if test -n "$PPMTOILBM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PPMTOILBM" >&5 -$as_echo "$PPMTOILBM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PPMTOILBM" >&5 +printf "%s\n" "$PPMTOILBM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6239,11 +6878,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "sed", so it can be a program name with args. set dummy sed; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_SED+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SED+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$SED"; then ac_cv_prog_SED="$SED" # Let the user override the test. else @@ -6251,11 +6891,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_SED="sed " - $as_echo "$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 @@ -6266,11 +6910,11 @@ fi fi SED=$ac_cv_prog_SED if test -n "$SED"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 -$as_echo "$SED" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +printf "%s\n" "$SED" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6286,11 +6930,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "chmod", so it can be a program name with args. set dummy chmod; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CHMOD+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CHMOD+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CHMOD"; then ac_cv_prog_CHMOD="$CHMOD" # Let the user override the test. else @@ -6298,11 +6943,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CHMOD="chmod " - $as_echo "$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 @@ -6313,11 +6962,11 @@ fi fi CHMOD=$ac_cv_prog_CHMOD if test -n "$CHMOD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 -$as_echo "$CHMOD" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 +printf "%s\n" "$CHMOD" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6333,11 +6982,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "patch", so it can be a program name with args. set dummy patch; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PATCH+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PATCH+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PATCH"; then ac_cv_prog_PATCH="$PATCH" # Let the user override the test. else @@ -6345,11 +6995,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PATCH="patch " - $as_echo "$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 @@ -6360,11 +7014,11 @@ fi fi PATCH=$ac_cv_prog_PATCH if test -n "$PATCH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5 -$as_echo "$PATCH" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5 +printf "%s\n" "$PATCH" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6387,8 +7041,8 @@ fi if test -n "$PYTHON"; then # If the user set $PYTHON, use it and don't search something else. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 3.0" >&5 -$as_echo_n "checking whether $PYTHON version is >= 3.0... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 3.0" >&5 +printf %s "checking whether $PYTHON version is >= 3.0... " >&6; } prog="import sys # split strings by '.' and convert to numeric. Append some zeros # because we need at least 4 digits for the hex conversion. @@ -6402,25 +7056,27 @@ sys.exit(sys.hexversion < minverhex)" ($PYTHON -c "$prog") >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + (exit $ac_status); } +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } as_fn_error $? "Python interpreter is too old" "$LINENO" 5 fi am_display_PYTHON=$PYTHON else # Otherwise, try each interpreter until we find one that satisfies # VERSION. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 3.0" >&5 -$as_echo_n "checking for a Python interpreter with version >= 3.0... " >&6; } -if ${am_cv_pathless_PYTHON+:} false; then : - $as_echo_n "(cached) " >&6 -else - - for am_cv_pathless_PYTHON in python python2 python3 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 3.0" >&5 +printf %s "checking for a Python interpreter with version >= 3.0... " >&6; } +if test ${am_cv_pathless_PYTHON+y} +then : + printf %s "(cached) " >&6 +else $as_nop + + for am_cv_pathless_PYTHON in python python2 python3 python3.11 python3.10 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do test "$am_cv_pathless_PYTHON" = none && break prog="import sys # split strings by '.' and convert to numeric. Append some zeros @@ -6435,24 +7091,26 @@ sys.exit(sys.hexversion < minverhex)" ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then : + (exit $ac_status); } +then : break fi done fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 -$as_echo "$am_cv_pathless_PYTHON" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 +printf "%s\n" "$am_cv_pathless_PYTHON" >&6; } # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON. if test "$am_cv_pathless_PYTHON" = none; then PYTHON=: else # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args. set dummy $am_cv_pathless_PYTHON; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_PYTHON+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PYTHON+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $PYTHON in [\\/]* | ?:[\\/]*) ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path. @@ -6462,11 +7120,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_PYTHON="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_PYTHON="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -6478,11 +7140,11 @@ esac fi PYTHON=$ac_cv_path_PYTHON if test -n "$PYTHON"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 -$as_echo "$PYTHON" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 +printf "%s\n" "$PYTHON" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6492,42 +7154,172 @@ fi if test "$PYTHON" = :; then - as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 + as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 else - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 -$as_echo_n "checking for $am_display_PYTHON version... " >&6; } -if ${am_cv_python_version+:} false; then : - $as_echo_n "(cached) " >&6 -else - am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[:3])"` + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 +printf %s "checking for $am_display_PYTHON version... " >&6; } +if test ${am_cv_python_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_version=`$PYTHON -c "import sys; print ('%u.%u' % sys.version_info[:2])"` fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 -$as_echo "$am_cv_python_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 +printf "%s\n" "$am_cv_python_version" >&6; } PYTHON_VERSION=$am_cv_python_version + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 +printf %s "checking for $am_display_PYTHON platform... " >&6; } +if test ${am_cv_python_platform+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 +printf "%s\n" "$am_cv_python_platform" >&6; } + PYTHON_PLATFORM=$am_cv_python_platform - PYTHON_PREFIX='${prefix}' - - PYTHON_EXEC_PREFIX='${exec_prefix}' + if test "x$prefix" = xNONE; then + am__usable_prefix=$ac_default_prefix + else + am__usable_prefix=$prefix + fi + # Allow user to request using sys.* values from Python, + # instead of the GNU $prefix values. + +# Check whether --with-python-sys-prefix was given. +if test ${with_python_sys_prefix+y} +then : + withval=$with_python_sys_prefix; am_use_python_sys=: +else $as_nop + am_use_python_sys=false +fi + + + # Allow user to override whatever the default Python prefix is. + +# Check whether --with-python_prefix was given. +if test ${with_python_prefix+y} +then : + withval=$with_python_prefix; am_python_prefix_subst=$withval + am_cv_python_prefix=$withval + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for explicit $am_display_PYTHON prefix" >&5 +printf %s "checking for explicit $am_display_PYTHON prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_prefix" >&5 +printf "%s\n" "$am_cv_python_prefix" >&6; } +else $as_nop + + if $am_use_python_sys; then + # using python sys.prefix value, not GNU + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python default $am_display_PYTHON prefix" >&5 +printf %s "checking for python default $am_display_PYTHON prefix... " >&6; } +if test ${am_cv_python_prefix+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.prefix)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_prefix" >&5 +printf "%s\n" "$am_cv_python_prefix" >&6; } + + case $am_cv_python_prefix in + $am__usable_prefix*) + am__strip_prefix=`echo "$am__usable_prefix" | sed 's|.|.|g'` + am_python_prefix_subst=`echo "$am_cv_python_prefix" | sed "s,^$am__strip_prefix,\\${prefix},"` + ;; + *) + am_python_prefix_subst=$am_cv_python_prefix + ;; + esac + else # using GNU prefix value, not python sys.prefix + am_python_prefix_subst='${prefix}' + am_python_prefix=$am_python_prefix_subst + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU default $am_display_PYTHON prefix" >&5 +printf %s "checking for GNU default $am_display_PYTHON prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_python_prefix" >&5 +printf "%s\n" "$am_python_prefix" >&6; } + fi +fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 -$as_echo_n "checking for $am_display_PYTHON platform... " >&6; } -if ${am_cv_python_platform+:} false; then : - $as_echo_n "(cached) " >&6 -else - am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` + # Substituting python_prefix_subst value. + PYTHON_PREFIX=$am_python_prefix_subst + + + # emacs-page Now do it all over again for Python exec_prefix, but with yet + # another conditional: fall back to regular prefix if that was specified. + +# Check whether --with-python_exec_prefix was given. +if test ${with_python_exec_prefix+y} +then : + withval=$with_python_exec_prefix; am_python_exec_prefix_subst=$withval + am_cv_python_exec_prefix=$withval + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for explicit $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for explicit $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } +else $as_nop + + # no explicit --with-python_exec_prefix, but if + # --with-python_prefix was given, use its value for python_exec_prefix too. + if test -n "$with_python_prefix" +then : + am_python_exec_prefix_subst=$with_python_prefix + am_cv_python_exec_prefix=$with_python_prefix + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python_prefix-given $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for python_prefix-given $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } +else $as_nop + + # Set am__usable_exec_prefix whether using GNU or Python values, + # since we use that variable for pyexecdir. + if test "x$exec_prefix" = xNONE; then + am__usable_exec_prefix=$am__usable_prefix + else + am__usable_exec_prefix=$exec_prefix + fi + # + if $am_use_python_sys; then # using python sys.exec_prefix, not GNU + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python default $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for python default $am_display_PYTHON exec_prefix... " >&6; } +if test ${am_cv_python_exec_prefix+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_exec_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } + case $am_cv_python_exec_prefix in + $am__usable_exec_prefix*) + am__strip_prefix=`echo "$am__usable_exec_prefix" | sed 's|.|.|g'` + am_python_exec_prefix_subst=`echo "$am_cv_python_exec_prefix" | sed "s,^$am__strip_prefix,\\${exec_prefix},"` + ;; + *) + am_python_exec_prefix_subst=$am_cv_python_exec_prefix + ;; + esac + else # using GNU $exec_prefix, not python sys.exec_prefix + am_python_exec_prefix_subst='${exec_prefix}' + am_python_exec_prefix=$am_python_exec_prefix_subst + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU default $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for GNU default $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_python_exec_prefix" >&5 +printf "%s\n" "$am_python_exec_prefix" >&6; } + fi +fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 -$as_echo "$am_cv_python_platform" >&6; } - PYTHON_PLATFORM=$am_cv_python_platform + # Substituting python_exec_prefix_subst. + PYTHON_EXEC_PREFIX=$am_python_exec_prefix_subst - # Just factor out some code duplication. + + # Factor out some code duplication into this shell variable. am_python_setup_sysconfig="\ import sys # Prefer sysconfig over distutils.sysconfig, for better compatibility @@ -6548,534 +7340,352 @@ except ImportError: pass" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5 -$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; } -if ${am_cv_python_pythondir+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "x$prefix" = xNONE - then - am_py_prefix=$ac_default_prefix - else - am_py_prefix=$prefix - fi - am_cv_python_pythondir=`$PYTHON -c " + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory (pythondir)" >&5 +printf %s "checking for $am_display_PYTHON script directory (pythondir)... " >&6; } +if test ${am_cv_python_pythondir+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "x$am_cv_python_prefix" = x; then + am_py_prefix=$am__usable_prefix + else + am_py_prefix=$am_cv_python_prefix + fi + am_cv_python_pythondir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('purelib', scheme, vars={'base':'$am_py_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pythondir in - $am_py_prefix*) - am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` - am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` - ;; - *) - case $am_py_prefix in - /usr|/System*) ;; - *) - am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,\\${PYTHON_PREFIX},"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) am_cv_python_pythondir="\${PYTHON_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac + ;; + esac fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 -$as_echo "$am_cv_python_pythondir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 +printf "%s\n" "$am_cv_python_pythondir" >&6; } pythondir=$am_cv_python_pythondir + pkgpythondir=\${pythondir}/$PACKAGE - pkgpythondir=\${pythondir}/$PACKAGE - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5 -$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; } -if ${am_cv_python_pyexecdir+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "x$exec_prefix" = xNONE - then - am_py_exec_prefix=$am_py_prefix - else - am_py_exec_prefix=$exec_prefix - fi - am_cv_python_pyexecdir=`$PYTHON -c " + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory (pyexecdir)" >&5 +printf %s "checking for $am_display_PYTHON extension module directory (pyexecdir)... " >&6; } +if test ${am_cv_python_pyexecdir+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "x$am_cv_python_exec_prefix" = x; then + am_py_exec_prefix=$am__usable_exec_prefix + else + am_py_exec_prefix=$am_cv_python_exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase':'$am_py_exec_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_exec_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pyexecdir in - $am_py_exec_prefix*) - am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` - am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` - ;; - *) - case $am_py_exec_prefix in - /usr|/System*) ;; - *) - am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,\\${PYTHON_EXEC_PREFIX},"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) am_cv_python_pyexecdir="\${PYTHON_EXEC_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac + ;; + esac fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 -$as_echo "$am_cv_python_pyexecdir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 +printf "%s\n" "$am_cv_python_pyexecdir" >&6; } pyexecdir=$am_cv_python_pyexecdir - - pkgpyexecdir=\${pyexecdir}/$PACKAGE + pkgpyexecdir=\${pyexecdir}/$PACKAGE fi - # Check whether --enable-libpng-config was given. -if test "${enable_libpng_config+set}" = set; then : +if test ${enable_libpng_config+y} +then : enableval=$enable_libpng_config; fi if test "$enable_libpng_config" != "no"; then # Extract the first word of "libpng-config", so it can be a program name with args. set dummy libpng-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_arosconfig_use_libpngconfig+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_arosconfig_use_libpngconfig+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$arosconfig_use_libpngconfig"; then ac_cv_prog_arosconfig_use_libpngconfig="$arosconfig_use_libpngconfig" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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_arosconfig_use_libpngconfig="yes" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - test -z "$ac_cv_prog_arosconfig_use_libpngconfig" && ac_cv_prog_arosconfig_use_libpngconfig="no" -fi -fi -arosconfig_use_libpngconfig=$ac_cv_prog_arosconfig_use_libpngconfig -if test -n "$arosconfig_use_libpngconfig"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $arosconfig_use_libpngconfig" >&5 -$as_echo "$arosconfig_use_libpngconfig" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test "$arosconfig_use_libpngconfig" = "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking libpng-config library" >&5 -$as_echo_n "checking libpng-config library... " >&6; } - libpng_incdir="`libpng-config --cflags`" - libpng_libextra="$libpng_libextra `libpng-config --ldflags`" - libpng="`libpng-config --libs`" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $libpng" >&5 -$as_echo "$libpng" >&6; } -else - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for png_read_png in -lpng" >&5 -$as_echo_n "checking for png_read_png in -lpng... " >&6; } -if ${ac_cv_lib_png_png_read_png+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lpng $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char png_read_png (); -int -main () -{ -return png_read_png (); - ; - return 0; -} -_ACEOF -if ac_fn_c_try_link "$LINENO"; then : - ac_cv_lib_png_png_read_png=yes -else - ac_cv_lib_png_png_read_png=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_png_png_read_png" >&5 -$as_echo "$ac_cv_lib_png_png_read_png" >&6; } -if test "x$ac_cv_lib_png_png_read_png" = xyes; then : - libpng="-lpng" -else - libpng="no" -fi - - if test "$libpng_libextra" != ""; then - if test "$libpng" != "no"; then - libpng_libextra="$libpng_libextra $libpng" - fi - fi -fi -req_avail=yes -if test "$libpng" = ""; then - req_avail=no -fi -if test "$libpng" = "no"; then - req_avail=no -fi -if test "$req_avail" = "no"; then - as_fn_error $? "libpng is required to build AROS. Please install and run configure again." "$LINENO" 5 -fi - - - - -FOR=for - -IF=if - -TEST=test - -CMP=cmp - - - -# Check for some includes for the X11 HIDD and the kernel - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 -$as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if ${ac_cv_path_GREP+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -z "$GREP"; then - ac_path_GREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in grep ggrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - as_fn_executable_p "$ac_path_GREP" || continue -# Check for GNU ac_path_GREP and select it if it is found. - # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in -*GNU*) - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo '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 - if test $ac_count -gt ${ac_path_GREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_GREP="$ac_path_GREP" - ac_path_GREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_GREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_GREP"; then - as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_GREP=$GREP -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -$as_echo "$ac_cv_path_GREP" >&6; } - GREP="$ac_cv_path_GREP" - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 -$as_echo_n "checking for egrep... " >&6; } -if ${ac_cv_path_EGREP+:} false; then : - $as_echo_n "(cached) " >&6 -else - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 - then ac_cv_path_EGREP="$GREP -E" - else - if test -z "$EGREP"; then - ac_path_EGREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in egrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - as_fn_executable_p "$ac_path_EGREP" || continue -# Check for GNU ac_path_EGREP and select it if it is found. - # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in -*GNU*) - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo '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 - if test $ac_count -gt ${ac_path_EGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_EGREP="$ac_path_EGREP" - ac_path_EGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_EGREP_found && break 3 - done - done +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_arosconfig_use_libpngconfig="yes" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done done IFS=$as_save_IFS - if test -z "$ac_cv_path_EGREP"; then - as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_EGREP=$EGREP -fi - fi + test -z "$ac_cv_prog_arosconfig_use_libpngconfig" && ac_cv_prog_arosconfig_use_libpngconfig="no" +fi +fi +arosconfig_use_libpngconfig=$ac_cv_prog_arosconfig_use_libpngconfig +if test -n "$arosconfig_use_libpngconfig"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $arosconfig_use_libpngconfig" >&5 +printf "%s\n" "$arosconfig_use_libpngconfig" >&6; } +else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -$as_echo "$ac_cv_path_EGREP" >&6; } - EGREP="$ac_cv_path_EGREP" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 -$as_echo_n "checking for ANSI C header files... " >&6; } -if ${ac_cv_header_stdc+:} false; then : - $as_echo_n "(cached) " >&6 +fi +if test "$arosconfig_use_libpngconfig" = "yes"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking libpng-config library" >&5 +printf %s "checking libpng-config library... " >&6; } + libpng_incdir="`libpng-config --cflags`" + libpng_libextra="$libpng_libextra `libpng-config --ldflags`" + libpng="`libpng-config --libs`" + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $libpng" >&5 +printf "%s\n" "$libpng" >&6; } else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for png_read_png in -lpng" >&5 +printf %s "checking for png_read_png in -lpng... " >&6; } +if test ${ac_cv_lib_png_png_read_png+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_check_lib_save_LIBS=$LIBS +LIBS="-lpng $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -#include -#include +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +char png_read_png (); int -main () +main (void) { - +return png_read_png (); ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_stdc=yes -else - ac_cv_header_stdc=no +if ac_fn_c_try_link "$LINENO" +then : + ac_cv_lib_png_png_read_png=yes +else $as_nop + ac_cv_lib_png_png_read_png=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_png_png_read_png" >&5 +printf "%s\n" "$ac_cv_lib_png_png_read_png" >&6; } +if test "x$ac_cv_lib_png_png_read_png" = xyes +then : + libpng="-lpng" +else $as_nop + libpng="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include + if test "$libpng_libextra" != ""; then + if test "$libpng" != "no"; then + libpng_libextra="$libpng_libextra $libpng" + fi + fi +fi +req_avail=yes +if test "$libpng" = ""; then + req_avail=no +fi +if test "$libpng" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "libpng is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then : -else - ac_cv_header_stdc=no -fi -rm -f conftest* -fi -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include +FOR=for + +IF=if + +TEST=test + +CMP=cmp + + + +# Check for some includes for the X11 HIDD and the kernel +ac_header= ac_cache= +for ac_item in $ac_header_c_list +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 + fi + ac_header= ac_cache= + elif test $ac_header; then + ac_cache=$ac_item + else + ac_header=$ac_item + fi +done -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then : -else - ac_cv_header_stdc=no -fi -rm -f conftest* -fi -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then : - : -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -if ac_fn_c_try_run "$LINENO"; then : -else - ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext -fi -fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 -$as_echo "$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then -$as_echo "#define STDC_HEADERS 1" >>confdefs.h +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 fi +ac_fn_c_check_header_compile "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ipc_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_IPC_H 1" >>confdefs.h -# On IRIX 5.3, sys/types and inttypes.h are conflicting. -for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ - inttypes.h stdint.h unistd.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default -" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_header_compile "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_shm_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_SHM_H 1" >>confdefs.h fi +ac_fn_c_check_header_compile "$LINENO" "sys/mmap.h" "ac_cv_header_sys_mmap_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_mmap_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MMAP_H 1" >>confdefs.h -done +fi +ac_fn_c_check_header_compile "$LINENO" "sys/mman.h" "ac_cv_header_sys_mman_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_mman_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MMAN_H 1" >>confdefs.h +fi +ac_fn_c_check_header_compile "$LINENO" "sysexits.h" "ac_cv_header_sysexits_h" "$ac_includes_default" +if test "x$ac_cv_header_sysexits_h" = xyes +then : + printf "%s\n" "#define HAVE_SYSEXITS_H 1" >>confdefs.h -for ac_header in sys/ipc.h sys/shm.h \ - sys/mmap.h sys/mman.h sysexits.h \ - sys/statfs.h sys/statvfs.h sys/vfs.h sys/param.h \ +fi +ac_fn_c_check_header_compile "$LINENO" "sys/statfs.h" "ac_cv_header_sys_statfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_statfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_STATFS_H 1" >>confdefs.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_header_compile "$LINENO" "sys/statvfs.h" "ac_cv_header_sys_statvfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_statvfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_STATVFS_H 1" >>confdefs.h fi +ac_fn_c_check_header_compile "$LINENO" "sys/vfs.h" "ac_cv_header_sys_vfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_vfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_VFS_H 1" >>confdefs.h -done +fi +ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_param_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h +fi -for ac_header in sys/mount.h -do : - ac_fn_c_check_header_compile "$LINENO" "sys/mount.h" "ac_cv_header_sys_mount_h" "#include + +ac_fn_c_check_header_compile "$LINENO" "sys/mount.h" "ac_cv_header_sys_mount_h" "#include " -if test "x$ac_cv_header_sys_mount_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_MOUNT_H 1 -_ACEOF +if test "x$ac_cv_header_sys_mount_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MOUNT_H 1" >>confdefs.h fi -done - -for ac_header in GL/glx.h + for ac_header in GL/glx.h do : - ac_fn_c_check_header_mongrel "$LINENO" "GL/glx.h" "ac_cv_header_GL_glx_h" "$ac_includes_default" -if test "x$ac_cv_header_GL_glx_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_GL_GLX_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "GL/glx.h" "ac_cv_header_GL_glx_h" "$ac_includes_default" +if test "x$ac_cv_header_GL_glx_h" = xyes +then : + printf "%s\n" "#define HAVE_GL_GLX_H 1" >>confdefs.h host_feature_glx=yes -else +else $as_nop host_feature_glx=no fi done - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __unused conflicts with sys/stat.h" >&5 -$as_echo_n "checking if __unused conflicts with sys/stat.h... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if __unused conflicts with sys/stat.h" >&5 +printf %s "checking if __unused conflicts with sys/stat.h... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7083,37 +7693,39 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext #include int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : host_stat_h__unused_used=no -else +else $as_nop host_stat_h__unused_used=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_stat_h__unused_used" >&5 -$as_echo "$host_stat_h__unused_used" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $host_stat_h__unused_used" >&5 +printf "%s\n" "$host_stat_h__unused_used" >&6; } ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do - as_ac_Header=`$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 -$as_echo_n "checking for $ac_hdr that defines DIR... " >&6; } -if eval \${$as_ac_Header+:} false; then : - $as_echo_n "(cached) " >&6 -else + as_ac_Header=`printf "%s\n" "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 +printf %s "checking for $ac_hdr that defines DIR... " >&6; } +if eval test \${$as_ac_Header+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include <$ac_hdr> int -main () +main (void) { if ((DIR *) 0) return 0; @@ -7121,19 +7733,21 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$as_ac_Header=yes" -else +else $as_nop eval "$as_ac_Header=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$as_ac_Header - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf "%s\n" "$ac_res" >&6; } +if eval test \"x\$"$as_ac_Header"\" = x"yes" +then : cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 +#define `printf "%s\n" "HAVE_$ac_hdr" | $as_tr_cpp` 1 _ACEOF ac_header_dirent=$ac_hdr; break @@ -7142,11 +7756,12 @@ fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 -$as_echo_n "checking for library containing opendir... " >&6; } -if ${ac_cv_search_opendir+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +printf %s "checking for library containing opendir... " >&6; } +if test ${ac_cv_search_opendir+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7154,56 +7769,59 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char opendir (); int -main () +main (void) { return opendir (); ; return 0; } _ACEOF -for ac_lib in '' dir; do +for ac_lib in '' dir +do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi - if ac_fn_c_try_link "$LINENO"; then : + if ac_fn_c_try_link "$LINENO" +then : ac_cv_search_opendir=$ac_res fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext - if ${ac_cv_search_opendir+:} false; then : + if test ${ac_cv_search_opendir+y} +then : break fi done -if ${ac_cv_search_opendir+:} false; then : +if test ${ac_cv_search_opendir+y} +then : -else +else $as_nop ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -$as_echo "$ac_cv_search_opendir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf "%s\n" "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir -if test "$ac_res" != no; then : +if test "$ac_res" != no +then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 -$as_echo_n "checking for library containing opendir... " >&6; } -if ${ac_cv_search_opendir+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +printf %s "checking for library containing opendir... " >&6; } +if test ${ac_cv_search_opendir+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7211,57 +7829,60 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char opendir (); int -main () +main (void) { return opendir (); ; return 0; } _ACEOF -for ac_lib in '' x; do +for ac_lib in '' x +do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi - if ac_fn_c_try_link "$LINENO"; then : + if ac_fn_c_try_link "$LINENO" +then : ac_cv_search_opendir=$ac_res fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext - if ${ac_cv_search_opendir+:} false; then : + if test ${ac_cv_search_opendir+y} +then : break fi done -if ${ac_cv_search_opendir+:} false; then : +if test ${ac_cv_search_opendir+y} +then : -else +else $as_nop ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -$as_echo "$ac_cv_search_opendir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf "%s\n" "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir -if test "$ac_res" != no; then : +if test "$ac_res" != no +then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 -$as_echo_n "checking whether stat file-mode macros are broken... " >&6; } -if ${ac_cv_header_stat_broken+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7284,138 +7905,174 @@ extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; #endif _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_header_stat_broken=no -else +else $as_nop ac_cv_header_stat_broken=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 -$as_echo "$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 -$as_echo "#define STAT_MACROS_BROKEN 1" >>confdefs.h - -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 -$as_echo_n "checking for ANSI C header files... " >&6; } -if ${ac_cv_header_stdc+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include - -int -main () -{ +printf "%s\n" "#define STAT_MACROS_BROKEN 1" >>confdefs.h - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_stdc=yes -else - ac_cv_header_stdc=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then : +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_prog in grep ggrep + do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + printf %s 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "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 + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi else - ac_cv_header_stdc=no -fi -rm -f conftest* - + ac_cv_path_GREP=$GREP fi -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then : - -else - ac_cv_header_stdc=no fi -rm -f conftest* +{ 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" -fi -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then : - : -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif +# Autoupdate added the next two lines to ensure that your configure +# script's behavior did not change. They are probably safe to remove. -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -if ac_fn_c_try_run "$LINENO"; then : +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_prog in egrep + do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + printf %s 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "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 + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi else - ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_cv_path_EGREP=$EGREP fi + fi fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 -$as_echo "$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then +{ 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" -$as_echo "#define STDC_HEADERS 1" >>confdefs.h -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 -$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } -if ${ac_cv_header_sys_wait_h+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 +printf %s "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } +if test ${ac_cv_header_sys_wait_h+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7428,7 +8085,7 @@ else #endif int -main () +main (void) { int s; wait (&s); @@ -7437,80 +8094,54 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_header_sys_wait_h=yes -else +else $as_nop ac_cv_header_sys_wait_h=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 -$as_echo "$ac_cv_header_sys_wait_h" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 +printf "%s\n" "$ac_cv_header_sys_wait_h" >&6; } if test $ac_cv_header_sys_wait_h = yes; then -$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h +printf "%s\n" "#define HAVE_SYS_WAIT_H 1" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5 -$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; } -if ${ac_cv_header_time+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -int -main () -{ -if ((struct tm *) 0) -return 0; - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_time=yes -else - ac_cv_header_time=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5 -$as_echo "$ac_cv_header_time" >&6; } -if test $ac_cv_header_time = yes; then -$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h +# Obsolete code to be removed. +if test $ac_cv_header_sys_time_h = yes; then + +printf "%s\n" "#define TIME_WITH_SYS_TIME 1" >>confdefs.h fi +# End of obsolete code. ac_fn_c_check_member "$LINENO" "struct stat" "st_blksize" "ac_cv_member_struct_stat_st_blksize" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_blksize" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_blksize" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_BLKSIZE 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_BLKSIZE 1" >>confdefs.h -$as_echo "#define HAVE_ST_BLKSIZE 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_BLKSIZE 1" >>confdefs.h fi ac_fn_c_check_member "$LINENO" "struct stat" "st_blocks" "ac_cv_member_struct_stat_st_blocks" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_blocks" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_blocks" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_BLOCKS 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_BLOCKS 1" >>confdefs.h -$as_echo "#define HAVE_ST_BLOCKS 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_BLOCKS 1" >>confdefs.h -else +else $as_nop case " $LIBOBJS " in *" fileblocks.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS fileblocks.$ac_objext" @@ -7521,30 +8152,30 @@ fi ac_fn_c_check_member "$LINENO" "struct stat" "st_rdev" "ac_cv_member_struct_stat_st_rdev" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_rdev" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_rdev" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_RDEV 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_RDEV 1" >>confdefs.h -$as_echo "#define HAVE_ST_RDEV 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_RDEV 1" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 -$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; } -if ${ac_cv_struct_tm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 +printf %s "checking whether struct tm is in sys/time.h or time.h... " >&6; } +if test ${ac_cv_struct_tm+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int -main () +main (void) { struct tm tm; int *p = &tm.tm_sec; @@ -7553,56 +8184,135 @@ struct tm tm; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_struct_tm=time.h -else +else $as_nop ac_cv_struct_tm=sys/time.h fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 -$as_echo "$ac_cv_struct_tm" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 +printf "%s\n" "$ac_cv_struct_tm" >&6; } if test $ac_cv_struct_tm = sys/time.h; then -$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h +printf "%s\n" "#define TM_IN_SYS_TIME 1" >>confdefs.h + +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; } +if test ${ac_cv_c_undeclared_builtin_options+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_CFLAGS=$CFLAGS + ac_cv_c_undeclared_builtin_options='cannot detect' + for ac_arg in '' -fno-builtin; do + CFLAGS="$ac_save_CFLAGS $ac_arg" + # This test program should *not* compile successfully. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ +(void) strchr; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + +else $as_nop + # This test program should compile successfully. + # No library function is consistently available on + # freestanding implementations, so test against a dummy + # declaration. Include always-available headers on the + # off chance that they somehow elicit warnings. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include +extern void ac_decl (int, char *); + +int +main (void) +{ +(void) ac_decl (0, (char *) 0); + (void) ac_decl; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + if test x"$ac_arg" = x +then : + ac_cv_c_undeclared_builtin_options='none needed' +else $as_nop + ac_cv_c_undeclared_builtin_options=$ac_arg +fi + break +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + done + CFLAGS=$ac_save_CFLAGS + +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; } + 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;} +as_fn_error $? "cannot make $CC report undeclared builtins +See \`config.log' for more details" "$LINENO" 5; } ;; #( + 'none needed') : + ac_c_undeclared_builtin_options='' ;; #( + *) : + ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; +esac ac_fn_c_check_member "$LINENO" "struct tm" "tm_zone" "ac_cv_member_struct_tm_tm_zone" "#include #include <$ac_cv_struct_tm> " -if test "x$ac_cv_member_struct_tm_tm_zone" = xyes; then : +if test "x$ac_cv_member_struct_tm_tm_zone" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_TM_TM_ZONE 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_TM_TM_ZONE 1" >>confdefs.h fi if test "$ac_cv_member_struct_tm_tm_zone" = yes; then -$as_echo "#define HAVE_TM_ZONE 1" >>confdefs.h +printf "%s\n" "#define HAVE_TM_ZONE 1" >>confdefs.h else - ac_fn_c_check_decl "$LINENO" "tzname" "ac_cv_have_decl_tzname" "#include -" -if test "x$ac_cv_have_decl_tzname" = xyes; then : + ac_fn_check_decl "$LINENO" "tzname" "ac_cv_have_decl_tzname" "#include +" "$ac_c_undeclared_builtin_options" "CFLAGS" +if test "x$ac_cv_have_decl_tzname" = xyes +then : ac_have_decl=1 -else +else $as_nop ac_have_decl=0 fi +printf "%s\n" "#define HAVE_DECL_TZNAME $ac_have_decl" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define HAVE_DECL_TZNAME $ac_have_decl -_ACEOF - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tzname" >&5 -$as_echo_n "checking for tzname... " >&6; } -if ${ac_cv_var_tzname+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for tzname" >&5 +printf %s "checking for tzname... " >&6; } +if test ${ac_cv_var_tzname+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7611,164 +8321,250 @@ extern char *tzname[]; #endif int -main () +main (void) { return tzname[0][0]; ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_var_tzname=yes -else +else $as_nop ac_cv_var_tzname=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_var_tzname" >&5 -$as_echo "$ac_cv_var_tzname" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_var_tzname" >&5 +printf "%s\n" "$ac_cv_var_tzname" >&6; } if test $ac_cv_var_tzname = yes; then -$as_echo "#define HAVE_TZNAME 1" >>confdefs.h +printf "%s\n" "#define HAVE_TZNAME 1" >>confdefs.h fi fi ac_fn_c_check_type "$LINENO" "off_t" "ac_cv_type_off_t" "$ac_includes_default" -if test "x$ac_cv_type_off_t" = xyes; then : +if test "x$ac_cv_type_off_t" = xyes +then : -else +else $as_nop -cat >>confdefs.h <<_ACEOF -#define off_t long int -_ACEOF +printf "%s\n" "#define off_t long int" >>confdefs.h fi -ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" -if test "x$ac_cv_type_pid_t" = xyes; then : -else + ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default +" +if test "x$ac_cv_type_pid_t" = xyes +then : + +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #if defined _WIN64 && !defined __CYGWIN__ + LLP64 + #endif + +int +main (void) +{ + + ; + return 0; +} -cat >>confdefs.h <<_ACEOF -#define pid_t int _ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_pid_type='int' +else $as_nop + ac_pid_type='__int64' +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 + fi + ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" -if test "x$ac_cv_type_size_t" = xyes; then : +if test "x$ac_cv_type_size_t" = xyes +then : -else +else $as_nop -cat >>confdefs.h <<_ACEOF -#define size_t unsigned int -_ACEOF +printf "%s\n" "#define size_t unsigned int" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 -$as_echo_n "checking for uid_t in sys/types.h... " >&6; } -if ${ac_cv_type_uid_t+:} false; then : - $as_echo_n "(cached) " >&6 -else + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 +printf %s "checking for uid_t in sys/types.h... " >&6; } +if test ${ac_cv_type_uid_t+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "uid_t" >/dev/null 2>&1; then : + $EGREP "uid_t" >/dev/null 2>&1 +then : ac_cv_type_uid_t=yes -else +else $as_nop ac_cv_type_uid_t=no fi -rm -f conftest* +rm -rf conftest* fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 -$as_echo "$ac_cv_type_uid_t" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 +printf "%s\n" "$ac_cv_type_uid_t" >&6; } if test $ac_cv_type_uid_t = no; then -$as_echo "#define uid_t int" >>confdefs.h +printf "%s\n" "#define uid_t int" >>confdefs.h -$as_echo "#define gid_t int" >>confdefs.h +printf "%s\n" "#define gid_t int" >>confdefs.h fi ac_fn_c_check_member "$LINENO" "struct tm" "tm_gmtoff" "ac_cv_member_struct_tm_tm_gmtoff" "$ac_includes_default" -if test "x$ac_cv_member_struct_tm_tm_gmtoff" = xyes; then : +if test "x$ac_cv_member_struct_tm_tm_gmtoff" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_TM_TM_GMTOFF 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_TM_TM_GMTOFF 1" >>confdefs.h fi # Look for some functions -for ac_func in getpagesize kqueue statfs statvfs \ - clone kse_create rfork_thread thr_create sa_register \ - getcontext makecontext setcontext sigaltstack swapcontext -do : - as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` -ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" -if eval test \"x\$"$as_ac_var"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 -_ACEOF +ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" +if test "x$ac_cv_func_getpagesize" = xyes +then : + printf "%s\n" "#define HAVE_GETPAGESIZE 1" >>confdefs.h fi -done +ac_fn_c_check_func "$LINENO" "kqueue" "ac_cv_func_kqueue" +if test "x$ac_cv_func_kqueue" = xyes +then : + printf "%s\n" "#define HAVE_KQUEUE 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "statfs" "ac_cv_func_statfs" +if test "x$ac_cv_func_statfs" = xyes +then : + printf "%s\n" "#define HAVE_STATFS 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "statvfs" "ac_cv_func_statvfs" +if test "x$ac_cv_func_statvfs" = xyes +then : + printf "%s\n" "#define HAVE_STATVFS 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "clone" "ac_cv_func_clone" +if test "x$ac_cv_func_clone" = xyes +then : + printf "%s\n" "#define HAVE_CLONE 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "kse_create" "ac_cv_func_kse_create" +if test "x$ac_cv_func_kse_create" = xyes +then : + printf "%s\n" "#define HAVE_KSE_CREATE 1" >>confdefs.h - for ac_header in $ac_header_list -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default -" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_func "$LINENO" "rfork_thread" "ac_cv_func_rfork_thread" +if test "x$ac_cv_func_rfork_thread" = xyes +then : + printf "%s\n" "#define HAVE_RFORK_THREAD 1" >>confdefs.h fi +ac_fn_c_check_func "$LINENO" "thr_create" "ac_cv_func_thr_create" +if test "x$ac_cv_func_thr_create" = xyes +then : + printf "%s\n" "#define HAVE_THR_CREATE 1" >>confdefs.h -done +fi +ac_fn_c_check_func "$LINENO" "sa_register" "ac_cv_func_sa_register" +if test "x$ac_cv_func_sa_register" = xyes +then : + printf "%s\n" "#define HAVE_SA_REGISTER 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "getcontext" "ac_cv_func_getcontext" +if test "x$ac_cv_func_getcontext" = xyes +then : + printf "%s\n" "#define HAVE_GETCONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "makecontext" "ac_cv_func_makecontext" +if test "x$ac_cv_func_makecontext" = xyes +then : + printf "%s\n" "#define HAVE_MAKECONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "setcontext" "ac_cv_func_setcontext" +if test "x$ac_cv_func_setcontext" = xyes +then : + printf "%s\n" "#define HAVE_SETCONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "sigaltstack" "ac_cv_func_sigaltstack" +if test "x$ac_cv_func_sigaltstack" = xyes +then : + printf "%s\n" "#define HAVE_SIGALTSTACK 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "swapcontext" "ac_cv_func_swapcontext" +if test "x$ac_cv_func_swapcontext" = xyes +then : + printf "%s\n" "#define HAVE_SWAPCONTEXT 1" >>confdefs.h +fi -for ac_func in getpagesize -do : - ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" -if test "x$ac_cv_func_getpagesize" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_GETPAGESIZE 1 -_ACEOF -fi +ac_func= +for ac_item in $ac_func_c_list +do + if test $ac_func; then + ac_fn_c_check_func "$LINENO" $ac_func ac_cv_func_$ac_func + if eval test \"x\$ac_cv_func_$ac_func\" = xyes; then + echo "#define $ac_item 1" >> confdefs.h + fi + ac_func= + else + ac_func=$ac_item + fi done -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 -$as_echo_n "checking for working mmap... " >&6; } -if ${ac_cv_func_mmap_fixed_mapped+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "$cross_compiling" = yes; then : - ac_cv_func_mmap_fixed_mapped=no -else + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 +printf %s "checking for working mmap... " >&6; } +if test ${ac_cv_func_mmap_fixed_mapped+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "$cross_compiling" = yes +then : + case "$host_os" in # (( + # Guess yes on platforms where we know the result. + linux*) ac_cv_func_mmap_fixed_mapped=yes ;; + # If we don't know, assume the worst. + *) ac_cv_func_mmap_fixed_mapped=no ;; + esac +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default @@ -7800,10 +8596,6 @@ $ac_includes_default #include #include -#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H -char *malloc (); -#endif - /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef _SC_PAGESIZE @@ -7837,7 +8629,7 @@ char *malloc (); #endif /* no HAVE_GETPAGESIZE */ int -main () +main (void) { char *data, *data2, *data3; const char *cdata2; @@ -7910,9 +8702,10 @@ main () return 0; } _ACEOF -if ac_fn_c_try_run "$LINENO"; then : +if ac_fn_c_try_run "$LINENO" +then : ac_cv_func_mmap_fixed_mapped=yes -else +else $as_nop ac_cv_func_mmap_fixed_mapped=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ @@ -7920,11 +8713,11 @@ rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 -$as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 +printf "%s\n" "$ac_cv_func_mmap_fixed_mapped" >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then -$as_echo "#define HAVE_MMAP 1" >>confdefs.h +printf "%s\n" "#define HAVE_MMAP 1" >>confdefs.h fi rm -f conftest.mmap conftest.txt @@ -7932,29 +8725,30 @@ rm -f conftest.mmap conftest.txt # # Disable common symbols -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-common" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fno-common... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-common" >&5 +printf %s "checking whether ${CC_BASE} accepts -fno-common... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fno-common" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_common="yes" -else +else $as_nop use_no_common="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_common" >&5 -$as_echo "$use_no_common" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_common" >&5 +printf "%s\n" "$use_no_common" >&6; } if test "x-$use_no_common" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -fno-common" fi @@ -7975,29 +8769,30 @@ CFLAGS="$save_cflags" # work on all platforms. # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-stack-protector" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fno-stack-protector... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-stack-protector" >&5 +printf %s "checking whether ${CC_BASE} accepts -fno-stack-protector... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fno-stack-protector" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_stack_protector="yes" -else +else $as_nop use_no_stack_protector="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 -$as_echo "$use_no_stack_protector" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +printf "%s\n" "$use_no_stack_protector" >&6; } if test "x-$use_no_stack_protector" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -fno-stack-protector" fi @@ -8008,29 +8803,30 @@ CFLAGS="$save_cflags" # Disable pointer-signedness warnings if the compiler recognises the option # (this only works for the host compiler at the moment) -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -Wno-pointer-sign" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -Wno-pointer-sign... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -Wno-pointer-sign" >&5 +printf %s "checking whether ${CC_BASE} accepts -Wno-pointer-sign... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -Wno-pointer-sign" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_sign_warning="yes" -else +else $as_nop use_no_sign_warning="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_sign_warning" >&5 -$as_echo "$use_no_sign_warning" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_sign_warning" >&5 +printf "%s\n" "$use_no_sign_warning" >&6; } if test "x-$use_no_sign_warning" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -Wno-pointer-sign" fi @@ -8040,29 +8836,30 @@ CFLAGS="$save_cflags" # Check if host compiler supports -fgnu89-inline, can be needed for crosstools. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fgnu89-inline" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fgnu89-inline... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fgnu89-inline" >&5 +printf %s "checking whether ${CC_BASE} accepts -fgnu89-inline... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fgnu89-inline" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_gnu89_inline="yes" -else +else $as_nop use_gnu89_inline="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_gnu89_inline" >&5 -$as_echo "$use_gnu89_inline" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_gnu89_inline" >&5 +printf "%s\n" "$use_gnu89_inline" >&6; } if test "x-$use_gnu89_inline" = "x-yes" ; then gnu89_inline="-fgnu89-inline" fi @@ -8072,28 +8869,29 @@ CFLAGS="$save_cflags" # For GCC < 4.0 -I- is used for giving the search path for '#include "..."' # On GCC >= 4.0 -iquote should be used # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -iquote" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -iquote... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -iquote" >&5 +printf %s "checking whether ${CC_BASE} accepts -iquote... " >&6; } CFLAGS="$CFLAGS -iquote." cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : has_iquote="yes" -else +else $as_nop has_iquote="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 -$as_echo "$has_iquote" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +printf "%s\n" "$has_iquote" >&6; } if test "x-$has_iquote" = "x-yes" ; then host_cflags_iquote=-iquote host_cflags_iquote_end= @@ -8102,8 +8900,8 @@ else host_cflags_iquote_end=-I- fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: Performing target configuration..." >&5 -$as_echo "$as_me: Performing target configuration..." >&6;} +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: Performing target configuration..." >&5 +printf "%s\n" "$as_me: Performing target configuration..." >&6;} test_kernel_cc=no @@ -8155,49 +8953,52 @@ ignore_undefined_symbols="" # Check for X11 by default need_x11="auto" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Which toolchain family to use ..." >&5 -$as_echo_n "checking Which toolchain family to use ...... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which toolchain family to use ..." >&5 +printf %s "checking Which toolchain family to use ...... " >&6; } # Check whether --with-toolchain was given. -if test "${with_toolchain+set}" = set; then : +if test ${with_toolchain+y} +then : withval=$with_toolchain; aros_toolchain="$withval" -else +else $as_nop aros_toolchain="$default_toolchain_family" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_toolchain" >&5 -$as_echo "$aros_toolchain" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_toolchain" >&5 +printf "%s\n" "$aros_toolchain" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable link time optimizations (LTO)" >&5 -$as_echo_n "checking if we should enable link time optimizations (LTO)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should enable link time optimizations (LTO)" >&5 +printf %s "checking if we should enable link time optimizations (LTO)... " >&6; } # Check whether --enable-lto was given. -if test "${enable_lto+set}" = set; then : +if test ${enable_lto+y} +then : enableval=$enable_lto; aros_config_lto="$enableval" -else +else $as_nop aros_config_lto="no" fi if test "$aros_config_lto" != "no"; then aros_config_lto="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_lto" >&5 -$as_echo "$aros_config_lto" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_config_lto" >&5 +printf "%s\n" "$aros_config_lto" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable coverage instrumentation" >&5 -$as_echo_n "checking if we should enable coverage instrumentation... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should enable coverage instrumentation" >&5 +printf %s "checking if we should enable coverage instrumentation... " >&6; } # Check whether --enable-coverage was given. -if test "${enable_coverage+set}" = set; then : +if test ${enable_coverage+y} +then : enableval=$enable_coverage; aros_config_coverage="$enableval" -else +else $as_nop aros_config_coverage="no" fi if test "$aros_config_coverage" != "no"; then aros_config_coverage="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_coverage" >&5 -$as_echo "$aros_config_coverage" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_config_coverage" >&5 +printf "%s\n" "$aros_config_coverage" >&6; } use_ld_wrapper=yes @@ -8252,8 +9053,8 @@ case "$aros_toolchain" in aros_cxx_ldflags="-static-libstdc++" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown toolchain family!\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown toolchain family!\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown toolchain family!\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown toolchain family!\"" >&2;} toolchain_c_compiler="cc" toolchain_cxx_compiler="c++" toolchain_cpp_preprocessor="cpp" @@ -8272,12 +9073,13 @@ esac #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which type of build to do" >&5 -$as_echo_n "checking which type of build to do... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which type of build to do" >&5 +printf %s "checking which type of build to do... " >&6; } # Check whether --enable-build_type was given. -if test "${enable_build_type+set}" = set; then : +if test ${enable_build_type+y} +then : enableval=$enable_build_type; build_type=$enableval -else +else $as_nop build_type="personal" fi @@ -8297,18 +9099,19 @@ fi aros_config_cppflags="$aros_config_cppflags -DAROS_BUILD_TYPE=AROS_BUILD_TYPE_$build_type_string" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $build_type" >&5 -$as_echo "$build_type" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $build_type" >&5 +printf "%s\n" "$build_type" >&6; } #----------------------------------------------------------------------------- all_debug_types="messages stack modules mungwall symbols" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug types to enable" >&5 -$as_echo_n "checking which debug types to enable... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which debug types to enable" >&5 +printf %s "checking which debug types to enable... " >&6; } # Check whether --enable-debug was given. -if test "${enable_debug+set}" = set; then : +if test ${enable_debug+y} +then : enableval=$enable_debug; debug="$enableval" -else +else $as_nop debug="" fi @@ -8347,8 +9150,8 @@ if test "$debug" != "none"; then done aros_debug="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $debug" >&5 -$as_echo "$debug" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $debug" >&5 +printf "%s\n" "$debug" >&6; } if test "$aros_messages_debug" = "1"; then aros_messages_debug="-DADEBUG=1 -DMDEBUG=1" @@ -8374,12 +9177,13 @@ aros_debug_ldflags="$aros_symbols_debug" # Always apply the transforms in this particular order. Basically you should # always run 'ccache distcc compiler' in that order for the best performance. # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable distcc" >&5 -$as_echo_n "checking whether to enable distcc... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable distcc" >&5 +printf %s "checking whether to enable distcc... " >&6; } # Check whether --enable-distcc was given. -if test "${enable_distcc+set}" = set; then : +if test ${enable_distcc+y} +then : enableval=$enable_distcc; distcc="$enableval" -else +else $as_nop distcc="no" fi @@ -8387,11 +9191,12 @@ if test "$distcc" != "" -a "$distcc" != "no"; then # AC_CHECK_PROG will print out the result in this case # Extract the first word of "distcc", so it can be a program name with args. set dummy distcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_DISTCC+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_DISTCC+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $DISTCC in [\\/]* | ?:[\\/]*) ac_cv_path_DISTCC="$DISTCC" # Let the user override the test with a path. @@ -8401,11 +9206,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_DISTCC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_DISTCC="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8418,25 +9227,26 @@ esac fi DISTCC=$ac_cv_path_DISTCC if test -n "$DISTCC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DISTCC" >&5 -$as_echo "$DISTCC" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DISTCC" >&5 +printf "%s\n" "$DISTCC" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable ccache" >&5 -$as_echo_n "checking whether to enable ccache... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable ccache" >&5 +printf %s "checking whether to enable ccache... " >&6; } # Check whether --enable-ccache was given. -if test "${enable_ccache+set}" = set; then : +if test ${enable_ccache+y} +then : enableval=$enable_ccache; ccache="$enableval" -else +else $as_nop ccache="no" fi @@ -8444,11 +9254,12 @@ if test "$ccache" != "" -a "$ccache" != "no"; then # AC_CHECK_PROG will print out the result in this case # Extract the first word of "ccache", so it can be a program name with args. set dummy ccache; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CCACHE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CCACHE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CCACHE"; then ac_cv_prog_CCACHE="$CCACHE" # Let the user override the test. else @@ -8456,11 +9267,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCACHE="ccache" - $as_echo "$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 @@ -8471,27 +9286,28 @@ fi fi CCACHE=$ac_cv_prog_CCACHE if test -n "$CCACHE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 -$as_echo "$CCACHE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 +printf "%s\n" "$CCACHE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific host gcc version to use" >&5 -$as_echo_n "checking what specific host gcc version to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific host gcc version to use" >&5 +printf %s "checking what specific host gcc version to use... " >&6; } # Check whether --with-kernel-gcc-version was given. -if test "${with_kernel_gcc_version+set}" = set; then : +if test ${with_kernel_gcc_version+y} +then : withval=$with_kernel_gcc_version; kernel_tool_version="$withval" -else +else $as_nop kernel_tool_version="" fi @@ -8500,17 +9316,18 @@ if test "$kernel_tool_version" != "" ; then else msg_result="default" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what optimization flags to use" >&5 -$as_echo_n "checking what optimization flags to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what optimization flags to use" >&5 +printf %s "checking what optimization flags to use... " >&6; } # Check whether --with-optimization was given. -if test "${with_optimization+set}" = set; then : +if test ${with_optimization+y} +then : withval=$with_optimization; optimization_level="$withval" -else +else $as_nop optimization_level="unknown" fi @@ -8524,18 +9341,19 @@ if test "$optimization_level" = "unknown"; then else optimization="$optimization_level" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization" >&5 -$as_echo "$optimization" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $optimization" >&5 +printf "%s\n" "$optimization" >&6; } paranoia_default=yes #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which paranoia flags to use" >&5 -$as_echo_n "checking which paranoia flags to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which paranoia flags to use" >&5 +printf %s "checking which paranoia flags to use... " >&6; } # Check whether --with-paranoia was given. -if test "${with_paranoia+set}" = set; then : +if test ${with_paranoia+y} +then : withval=$with_paranoia; paranoia_flags="$withval" -else +else $as_nop paranoia_flags="$paranoia_default" fi @@ -8548,17 +9366,18 @@ else fi msg_result="$paranoia_flags" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } aros_warn_flags="$aros_warn_flags $paranoia_flags" #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what target variant to enable" >&5 -$as_echo_n "checking what target variant to enable... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what target variant to enable" >&5 +printf %s "checking what target variant to enable... " >&6; } # Check whether --enable-target_variant was given. -if test "${enable_target_variant+set}" = set; then : +if test ${enable_target_variant+y} +then : enableval=$enable_target_variant; target_variant=$enableval -else +else $as_nop target_variant="" fi @@ -8570,16 +9389,17 @@ else aros_target_variant="$target_variant" aros_target_suffix="-$target_variant" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5 -$as_echo "$enableval" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5 +printf "%s\n" "$enableval" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro name to use" >&5 -$as_echo_n "checking what distro name to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro name to use" >&5 +printf %s "checking what distro name to use... " >&6; } # Check whether --enable-dist_name was given. -if test "${enable_dist_name+set}" = set; then : +if test ${enable_dist_name+y} +then : enableval=$enable_dist_name; dist_name="$enableval" -else +else $as_nop dist_name="" fi @@ -8588,16 +9408,17 @@ if test "$dist_name" = ""; then else aros_dist_name="$dist_name" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_name" >&5 -$as_echo "$aros_dist_name" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_name" >&5 +printf "%s\n" "$aros_dist_name" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro version" >&5 -$as_echo_n "checking what distro version... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro version" >&5 +printf %s "checking what distro version... " >&6; } # Check whether --enable-dist_version was given. -if test "${enable_dist_version+set}" = set; then : +if test ${enable_dist_version+y} +then : enableval=$enable_dist_version; dist_version="$enableval" -else +else $as_nop dist_version="" fi @@ -8606,16 +9427,17 @@ if test "$dist_version" = ""; then else aros_dist_version="$dist_version" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_version" >&5 -$as_echo "$aros_dist_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_version" >&5 +printf "%s\n" "$aros_dist_version" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro date" >&5 -$as_echo_n "checking what distro date... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro date" >&5 +printf %s "checking what distro date... " >&6; } # Check whether --enable-dist_date was given. -if test "${enable_dist_date+set}" = set; then : +if test ${enable_dist_date+y} +then : enableval=$enable_dist_date; dist_date=$enableval -else +else $as_nop dist_date="" fi @@ -8624,16 +9446,17 @@ if test "$dist_date" = ""; then else aros_dist_date="$dist_date" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_date" >&5 -$as_echo "$aros_dist_date" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_date" >&5 +printf "%s\n" "$aros_dist_date" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro amigadate" >&5 -$as_echo_n "checking what distro amigadate... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro amigadate" >&5 +printf %s "checking what distro amigadate... " >&6; } # Check whether --enable-dist_amigadate was given. -if test "${enable_dist_amigadate+set}" = set; then : +if test ${enable_dist_amigadate+y} +then : enableval=$enable_dist_amigadate; dist_amigadate=$enableval -else +else $as_nop dist_amigadate="" fi @@ -8642,8 +9465,8 @@ if test "$dist_amigadate" = ""; then else aros_dist_amigadate="$dist_amigadate" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_amigadate" >&5 -$as_echo "$aros_dist_amigadate" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_amigadate" >&5 +printf "%s\n" "$aros_dist_amigadate" >&6; } #----------------------------------------------------------------------------- @@ -8659,73 +9482,78 @@ ENABLE_EXECSMP= case "$aros_target_variant" in ios) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking XCode path" >&5 -$as_echo_n "checking XCode path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking XCode path" >&5 +printf %s "checking XCode path... " >&6; } # Check whether --with-xcode was given. -if test "${with_xcode+set}" = set; then : +if test ${with_xcode+y} +then : withval=$with_xcode; aros_xcode_path="$withval" -else +else $as_nop aros_xcode_path="/Developer" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_xcode_path" >&5 -$as_echo "$aros_xcode_path" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_xcode_path" >&5 +printf "%s\n" "$aros_xcode_path" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what iOS SDK version to use" >&5 -$as_echo_n "checking what iOS SDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what iOS SDK version to use" >&5 +printf %s "checking what iOS SDK version to use... " >&6; } # Check whether --with-sdk-version was given. -if test "${with_sdk_version+set}" = set; then : +if test ${with_sdk_version+y} +then : withval=$with_sdk_version; aros_sdk_version="$withval" -else +else $as_nop aros_sdk_version="4.1" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 -$as_echo "$aros_sdk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +printf "%s\n" "$aros_sdk_version" >&6; } ;; "android") - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android SDK path" >&5 -$as_echo_n "checking Android SDK path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Android SDK path" >&5 +printf %s "checking Android SDK path... " >&6; } # Check whether --with-sdk was given. -if test "${with_sdk+set}" = set; then : +if test ${with_sdk+y} +then : withval=$with_sdk; aros_android_sdk="$withval" -else +else $as_nop aros_android_sdk=$default_android_sdk fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_sdk" >&5 -$as_echo "$aros_android_sdk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_sdk" >&5 +printf "%s\n" "$aros_android_sdk" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android NDK path" >&5 -$as_echo_n "checking Android NDK path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Android NDK path" >&5 +printf %s "checking Android NDK path... " >&6; } # Check whether --with-ndk was given. -if test "${with_ndk+set}" = set; then : +if test ${with_ndk+y} +then : withval=$with_ndk; aros_android_ndk="$withval" -else +else $as_nop aros_android_ndk="none" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_ndk" >&5 -$as_echo "$aros_android_ndk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_ndk" >&5 +printf "%s\n" "$aros_android_ndk" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android SDK version to use" >&5 -$as_echo_n "checking what Android SDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what Android SDK version to use" >&5 +printf %s "checking what Android SDK version to use... " >&6; } # Check whether --with-sdk-version was given. -if test "${with_sdk_version+set}" = set; then : +if test ${with_sdk_version+y} +then : withval=$with_sdk_version; aros_sdk_version="$withval" -else +else $as_nop aros_sdk_version="12" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 -$as_echo "$aros_sdk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +printf "%s\n" "$aros_sdk_version" >&6; } aros_android_level=android-$aros_sdk_version if test ! -d $aros_android_sdk/platforms/$aros_android_level; then @@ -8739,11 +9567,12 @@ $as_echo "$aros_sdk_version" >&6; } export PATH="$aros_android_sdk/tools:$PATH" # Extract the first word of "$android_tool", so it can be a program name with args. set dummy $android_tool; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_android_tool+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_android_tool+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $android_tool in [\\/]* | ?:[\\/]*) ac_cv_path_android_tool="$android_tool" # Let the user override the test with a path. @@ -8753,11 +9582,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_android_tool="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_android_tool="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8769,11 +9602,11 @@ esac fi android_tool=$ac_cv_path_android_tool if test -n "$android_tool"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $android_tool" >&5 -$as_echo "$android_tool" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $android_tool" >&5 +printf "%s\n" "$android_tool" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -8789,27 +9622,29 @@ if test "$req_avail" = "no"; then fi if test "$aros_android_ndk" != "none"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android NDK version to use" >&5 -$as_echo_n "checking what Android NDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what Android NDK version to use" >&5 +printf %s "checking what Android NDK version to use... " >&6; } # Check whether --with-ndk-version was given. -if test "${with_ndk_version+set}" = set; then : +if test ${with_ndk_version+y} +then : withval=$with_ndk_version; aros_ndk_version="$withval" -else +else $as_nop aros_ndk_version="9" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_ndk_version" >&5 -$as_echo "$aros_ndk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_ndk_version" >&5 +printf "%s\n" "$aros_ndk_version" >&6; } fi # Extract the first word of "ant", so it can be a program name with args. set dummy ant; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_ant+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_ant+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $ant in [\\/]* | ?:[\\/]*) ac_cv_path_ant="$ant" # Let the user override the test with a path. @@ -8819,11 +9654,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_ant="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_ant="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8835,34 +9674,35 @@ esac fi ant=$ac_cv_path_ant if test -n "$ant"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ant" >&5 -$as_echo "$ant" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ant" >&5 +printf "%s\n" "$ant" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi if test "$ant" = ""; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&5 -$as_echo "$as_me: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&5 +printf "%s\n" "$as_me: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&2;} fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Build debug or release apk" >&5 -$as_echo_n "checking Build debug or release apk... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Build debug or release apk" >&5 +printf %s "checking Build debug or release apk... " >&6; } # Check whether --with-apk-version was given. -if test "${with_apk_version+set}" = set; then : +if test ${with_apk_version+y} +then : withval=$with_apk_version; aros_android_antapk=$withval -else +else $as_nop aros_android_antapk=release fi if test $aros_android_antapk != release -a $aros_android_antapk != debug; then as_fn_error $? "apk-version has to be release or debug" "$LINENO" 5 fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_antapk" >&5 -$as_echo "$aros_android_antapk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_antapk" >&5 +printf "%s\n" "$aros_android_antapk" >&6; } target_extra_cfg+="$export_newline""# Android$export_newline""AROS_ANDROID_ANTAPK := $aros_android_antapk$export_newline" host_extra_cfg+="$export_newline""# Android-specific$export_newline""ANDROID := $android_tool$export_newline""ANT := $ant$export_newline" @@ -9584,7 +10424,8 @@ case "$target_os" in case "$target_cpu" in *m68k*) # Check whether --enable-amigaos_compliance was given. -if test "${enable_amigaos_compliance+set}" = set; then : +if test ${enable_amigaos_compliance+y} +then : enableval=$enable_amigaos_compliance; aros_amigaos_compliance="$enableval" fi @@ -9750,34 +10591,37 @@ crosstools_guess="yes" aros_target_toolchain="no" aros_kernel_sysroot="" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Kernel toolchain prefix" >&5 -$as_echo_n "checking Kernel toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Kernel toolchain prefix" >&5 +printf %s "checking Kernel toolchain prefix... " >&6; } # Check whether --with-kernel-toolchain-prefix was given. -if test "${with_kernel_toolchain_prefix+set}" = set; then : +if test ${with_kernel_toolchain_prefix+y} +then : withval=$with_kernel_toolchain_prefix; kernel_tool_prefix="$withval" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 -$as_echo "$kernel_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +printf "%s\n" "$kernel_tool_prefix" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ELF toolchain prefix" >&5 -$as_echo_n "checking ELF toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking ELF toolchain prefix" >&5 +printf %s "checking ELF toolchain prefix... " >&6; } # Check whether --with-elf-toolchain-prefix was given. -if test "${with_elf_toolchain_prefix+set}" = set; then : +if test ${with_elf_toolchain_prefix+y} +then : withval=$with_elf_toolchain_prefix; elf_tool_prefix="$withval" crosstools_guess="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $elf_tool_prefix" >&5 -$as_echo "$elf_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $elf_tool_prefix" >&5 +printf "%s\n" "$elf_tool_prefix" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS toolchain prefix" >&5 -$as_echo_n "checking AROS toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking AROS toolchain prefix" >&5 +printf %s "checking AROS toolchain prefix... " >&6; } # Check whether --with-aros-toolchain was given. -if test "${with_aros_toolchain+set}" = set; then : +if test ${with_aros_toolchain+y} +then : withval=$with_aros_toolchain; aros_tool_prefix="$withval" crosstools_guess="no" fi @@ -9785,22 +10629,23 @@ fi if test "$aros_tool_prefix" = "yes" ; then aros_tool_prefix=$aros_target_cpu-aros- fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 -$as_echo "$aros_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +printf "%s\n" "$aros_tool_prefix" >&6; } #----------------------------------------------------------------------------- # Checking if we should build crosstools.. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build crosstools" >&5 -$as_echo_n "checking whether to build crosstools... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build crosstools" >&5 +printf %s "checking whether to build crosstools... " >&6; } # Check whether --enable-crosstools was given. -if test "${enable_crosstools+set}" = set; then : +if test ${enable_crosstools+y} +then : enableval=$enable_crosstools; crosstools="$enableval" -else +else $as_nop crosstools="$crosstools_guess" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $crosstools" >&5 -$as_echo "$crosstools" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $crosstools" >&5 +printf "%s\n" "$crosstools" >&6; } if test "${crosstools}" = "yes"; then if test "${crosstools_guess}" = "no"; then @@ -9812,11 +10657,12 @@ if test "${crosstools}" = "yes" || test "${crosstools_guess}" = "no"; then aros_target_toolchain="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to install the crosstools binaries" >&5 -$as_echo_n "checking where to install the crosstools binaries... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to install the crosstools binaries" >&5 +printf %s "checking where to install the crosstools binaries... " >&6; } # Check whether --with-aros-toolchain-install was given. -if test "${with_aros_toolchain_install+set}" = set; then : +if test ${with_aros_toolchain_install+y} +then : withval=$with_aros_toolchain_install; aros_toolchain_install=$withval fi @@ -9831,19 +10677,20 @@ else fi fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_CROSSTOOLSDIR" >&5 -$as_echo "$AROS_CROSSTOOLSDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_CROSSTOOLSDIR" >&5 +printf "%s\n" "$AROS_CROSSTOOLSDIR" >&6; } #----------------------------------------------------------------------------- if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target binutils version to use" >&5 -$as_echo_n "checking what specific target binutils version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target binutils version to use" >&5 +printf %s "checking what specific target binutils version to use... " >&6; } fi # Check whether --with-binutils-version was given. -if test "${with_binutils_version+set}" = set; then : +if test ${with_binutils_version+y} +then : withval=$with_binutils_version; use_binutils_version="$withval" -else +else $as_nop use_binutils_version="" fi @@ -9853,8 +10700,8 @@ else target_binutils_version="$use_binutils_version" fi if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_binutils_version" >&5 -$as_echo "$target_binutils_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_binutils_version" >&5 +printf "%s\n" "$target_binutils_version" >&6; } fi @@ -9863,14 +10710,15 @@ fi #----------------------------------------------------------------------------- if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target gcc version to use" >&5 -$as_echo_n "checking what specific target gcc version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target gcc version to use" >&5 +printf %s "checking what specific target gcc version to use... " >&6; } fi # Check whether --with-gcc-version was given. -if test "${with_gcc_version+set}" = set; then : +if test ${with_gcc_version+y} +then : withval=$with_gcc_version; use_gcc_version="$withval" -else +else $as_nop use_gcc_version="" fi @@ -9879,22 +10727,24 @@ if test "$use_gcc_version" = ""; then if test "x$aros_toolchain_install" != "x"; then target_gcc_version="" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5 -$as_echo_n "checking gcc version... " >&6; } -if ${ax_cv_gcc_version+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5 +printf %s "checking gcc version... " >&6; } +if test ${ax_cv_gcc_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop ax_cv_gcc_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" - if test "x$ax_cv_gcc_version" = "x"; then : + if test "x$ax_cv_gcc_version" = "x" +then : ax_cv_gcc_version="" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_gcc_version" >&5 -$as_echo "$ax_cv_gcc_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_gcc_version" >&5 +printf "%s\n" "$ax_cv_gcc_version" >&6; } target_gcc_version=$ax_cv_gcc_version @@ -9907,20 +10757,20 @@ else target_gcc_version="$use_gcc_version" fi if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_gcc_version" >&5 -$as_echo "$target_gcc_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_gcc_version" >&5 +printf "%s\n" "$target_gcc_version" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking version string style" >&5 -$as_echo_n "checking version string style... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking version string style" >&5 +printf %s "checking version string style... " >&6; } if test "${target_gcc_version#*$'-'}" != "$target_gcc_version" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: snapshot" >&5 -$as_echo "snapshot" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: snapshot" >&5 +printf "%s\n" "snapshot" >&6; } GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'-' -f1) GCC_VERSION_MINOR=-1 GCC_VERSION_PATCH=-1 else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: release" >&5 -$as_echo "release" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: release" >&5 +printf "%s\n" "release" >&6; } GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'.' -f1) GCC_VERSION_MINOR=$(echo $target_gcc_version | cut -d'.' -f2) GCC_VERSION_PATCH=$(echo $target_gcc_version | cut -d'.' -f3) @@ -9955,14 +10805,15 @@ fi if test "$aros_toolchain" = "llvm" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target llvm version to use" >&5 -$as_echo_n "checking what specific target llvm version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target llvm version to use" >&5 +printf %s "checking what specific target llvm version to use... " >&6; } fi # Check whether --with-llvm-version was given. -if test "${with_llvm_version+set}" = set; then : +if test ${with_llvm_version+y} +then : withval=$with_llvm_version; use_llvm_version="$withval" -else +else $as_nop use_llvm_version="" fi @@ -9971,22 +10822,24 @@ if test "$use_llvm_version" = ""; then if test "x$aros_toolchain_install" != "x"; then target_llvm_version="" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking llvm version" >&5 -$as_echo_n "checking llvm version... " >&6; } -if ${ax_cv_llvm_version+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking llvm version" >&5 +printf %s "checking llvm version... " >&6; } +if test ${ax_cv_llvm_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop ax_cv_llvm_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" - if test "x$ax_cv_llvm_version" = "x"; then : + if test "x$ax_cv_llvm_version" = "x" +then : ax_cv_llvm_version="" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_llvm_version" >&5 -$as_echo "$ax_cv_llvm_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_llvm_version" >&5 +printf "%s\n" "$ax_cv_llvm_version" >&6; } target_llvm_version=$ax_cv_llvm_version @@ -9999,39 +10852,41 @@ else target_llvm_version="$use_llvm_version" fi if test "$aros_toolchain" = "llvm" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_llvm_version" >&5 -$as_echo "$target_llvm_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_llvm_version" >&5 +printf "%s\n" "$target_llvm_version" >&6; } aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_COMMON)" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Objective-C suppport" >&5 -$as_echo_n "checking whether to enable Objective-C suppport... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable Objective-C suppport" >&5 +printf %s "checking whether to enable Objective-C suppport... " >&6; } # Check whether --enable-objc was given. -if test "${enable_objc+set}" = set; then : +if test ${enable_objc+y} +then : enableval=$enable_objc; objc="$enableval" -else +else $as_nop objc="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $objc" >&5 -$as_echo "$objc" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $objc" >&5 +printf "%s\n" "$objc" >&6; } if test "x$objc" = "xyes"; then objc_target="$objc" else objc_target="no-objc" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Java suppport" >&5 -$as_echo_n "checking whether to enable Java suppport... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable Java suppport" >&5 +printf %s "checking whether to enable Java suppport... " >&6; } # Check whether --enable-java was given. -if test "${enable_java+set}" = set; then : +if test ${enable_java+y} +then : enableval=$enable_java; java="$enableval" -else +else $as_nop java="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $java" >&5 -$as_echo "$java" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $java" >&5 +printf "%s\n" "$java" >&6; } if test "x$java" != "xno"; then java_target="$java" else @@ -10053,18 +10908,19 @@ case "$aros_target_cpu" in aros_isa_extra="$aros_isa_extra$m68k_020_ldflags$export_newline$m68k_030_ldflags$export_newline$m68k_040_ldflags$export_newline$m68k_060_ldflags$export_newline" aros_isa_extra="$aros_isa_extra$m68k_020_ext$export_newline$m68k_030_ext$export_newline$m68k_040_ext$export_newline$m68k_060_ext$export_newline" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 -$as_echo_n "checking Which minimum CPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +printf %s "checking Which minimum CPU to use... " >&6; } # Check whether --with-cpu was given. -if test "${with_cpu+set}" = set; then : +if test ${with_cpu+y} +then : withval=$with_cpu; aros_gcc_cpu="$withval" -else +else $as_nop aros_gcc_cpu=$gcc_default_cpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 -$as_echo "$aros_gcc_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +printf "%s\n" "$aros_gcc_cpu" >&6; } if test "$gcc_default_cpu" != "$aros_gcc_cpu"; then aros_target_cpu_extra=$aros_gcc_cpu fi @@ -10091,54 +10947,57 @@ $as_echo "$aros_gcc_cpu" >&6; } fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 -$as_echo_n "checking Which minimum CPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +printf %s "checking Which minimum CPU to use... " >&6; } # Check whether --with-cpu was given. -if test "${with_cpu+set}" = set; then : +if test ${with_cpu+y} +then : withval=$with_cpu; aros_gcc_cpu="$withval" -else +else $as_nop aros_gcc_cpu=$gcc_default_cpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 -$as_echo "$aros_gcc_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +printf "%s\n" "$aros_gcc_cpu" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum FPU to use" >&5 -$as_echo_n "checking Which minimum FPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum FPU to use" >&5 +printf %s "checking Which minimum FPU to use... " >&6; } # Check whether --with-fpu was given. -if test "${with_fpu+set}" = set; then : +if test ${with_fpu+y} +then : withval=$with_fpu; aros_gcc_fpu="$withval" -else +else $as_nop aros_gcc_fpu=$gcc_default_fpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_fpu" >&5 -$as_echo "$aros_gcc_fpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_fpu" >&5 +printf "%s\n" "$aros_gcc_fpu" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which floating point ABI to use" >&5 -$as_echo_n "checking Which floating point ABI to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which floating point ABI to use" >&5 +printf %s "checking Which floating point ABI to use... " >&6; } # Check whether --with-float was given. -if test "${with_float+set}" = set; then : +if test ${with_float+y} +then : withval=$with_float; aros_gcc_float_abi="$withval" -else +else $as_nop aros_gcc_float_abi=$gcc_default_float_abi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_float_abi" >&5 -$as_echo "$aros_gcc_float_abi" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_float_abi" >&5 +printf "%s\n" "$aros_gcc_float_abi" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which ARM mode to use" >&5 -$as_echo_n "checking Which ARM mode to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which ARM mode to use" >&5 +printf %s "checking Which ARM mode to use... " >&6; } if test "$aros_target_cpu_mode" = ""; then aros_target_cpu_mode="arm32" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Defaulting to $aros_target_cpu_mode" >&5 -$as_echo "Defaulting to $aros_target_cpu_mode" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Defaulting to $aros_target_cpu_mode" >&5 +printf "%s\n" "Defaulting to $aros_target_cpu_mode" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cpu_mode" >&5 -$as_echo "$aros_target_cpu_mode" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_cpu_mode" >&5 +printf "%s\n" "$aros_target_cpu_mode" >&6; } fi case "$aros_target_cpu_mode" in @@ -10190,13 +11049,14 @@ if test "$gcc_target_cpu" != ""; then gcc_target_cpu="-D__${gcc_target_cpu}__" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to download sourcecode for external ports" >&5 -$as_echo_n "checking where to download sourcecode for external ports... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to download sourcecode for external ports" >&5 +printf %s "checking where to download sourcecode for external ports... " >&6; } # Check whether --with-portssources was given. -if test "${with_portssources+set}" = set; then : +if test ${with_portssources+y} +then : withval=$with_portssources; with_portssrcdir=$withval -else +else $as_nop with_portssrcdir="default" fi @@ -10205,16 +11065,17 @@ if test "$with_portssrcdir" = "default"; then else AROS_PORTSSRCDIR="$with_portssrcdir" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_PORTSSRCDIR" >&5 -$as_echo "$AROS_PORTSSRCDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_PORTSSRCDIR" >&5 +printf "%s\n" "$AROS_PORTSSRCDIR" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which bootloader to use" >&5 -$as_echo_n "checking which bootloader to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which bootloader to use" >&5 +printf %s "checking which bootloader to use... " >&6; } # Check whether --with-bootloader was given. -if test "${with_bootloader+set}" = set; then : +if test ${with_bootloader+y} +then : withval=$with_bootloader; target_bootloader=$withval -else +else $as_nop target_bootloader=$target_bootloader fi @@ -10223,16 +11084,17 @@ if test "$target_bootloader" = "none"; then else aros_target_bootloader="$target_bootloader" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_bootloader" >&5 -$as_echo "$target_bootloader" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_bootloader" >&5 +printf "%s\n" "$target_bootloader" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which icon-set to use" >&5 -$as_echo_n "checking which icon-set to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which icon-set to use" >&5 +printf %s "checking which icon-set to use... " >&6; } # Check whether --with-iconset was given. -if test "${with_iconset+set}" = set; then : +if test ${with_iconset+y} +then : withval=$with_iconset; target_iconset=$withval -else +else $as_nop target_iconset="default" fi @@ -10242,16 +11104,17 @@ if test "$target_iconset" = "default"; then else aros_target_iconset="$target_iconset" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_iconset" >&5 -$as_echo "$target_iconset" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_iconset" >&5 +printf "%s\n" "$target_iconset" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which GUI Theme to use" >&5 -$as_echo_n "checking which GUI Theme to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which GUI Theme to use" >&5 +printf %s "checking which GUI Theme to use... " >&6; } # Check whether --with-theme was given. -if test "${with_theme+set}" = set; then : +if test ${with_theme+y} +then : withval=$with_theme; target_guitheme=$withval -else +else $as_nop target_guitheme="default" fi @@ -10260,8 +11123,8 @@ if test "$target_guitheme" = "default"; then else aros_target_guitheme="$target_guitheme" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_guitheme" >&5 -$as_echo "$aros_target_guitheme" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_guitheme" >&5 +printf "%s\n" "$aros_target_guitheme" >&6; } # Find out if we are cross-compiling (i.e. if we can't use the host compiler # for target code) @@ -10351,10 +11214,10 @@ elif test "$aros_toolchain" = "llvm" ; then fi if test "$kernel_tool_prefix" != "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking which kernel tools" >&5 -$as_echo_n "checking which kernel tools... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 -$as_echo "$kernel_tool_prefix" >&6; }; + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which kernel tools" >&5 +printf %s "checking which kernel tools... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +printf "%s\n" "$kernel_tool_prefix" >&6; }; fi if test "$kernel_tool_prefix" = "none" ; then @@ -10382,11 +11245,12 @@ if test "$aros_kernel_cpp" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cpp", so it can be a program name with args. set dummy ${kernel_tool_prefix}cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10396,11 +11260,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10412,11 +11280,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10431,11 +11299,12 @@ if test "$GCC" = "yes"; then aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. set dummy `basename $aros_gcc_cpp`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10445,11 +11314,15 @@ else for as_dir in `dirname $aros_gcc_cpp` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10461,11 +11334,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10475,11 +11348,12 @@ if test "$aros_kernel_cpp" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10489,11 +11363,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10505,11 +11383,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10523,11 +11401,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cpp" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cpp", so it can be a program name with args. set dummy $aros_kernel_cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10537,11 +11416,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10553,11 +11436,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10590,11 +11473,12 @@ if test "$aros_kernel_cc" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cc", so it can be a program name with args. set dummy ${kernel_tool_prefix}cc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10604,11 +11488,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10620,11 +11508,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10639,11 +11527,12 @@ if test "$GCC" = "yes"; then aros_gcc_cc=`$CC -print-prog-name=$ac_tool_cc` # Extract the first word of "`basename $aros_gcc_[cc]`", so it can be a program name with args. set dummy `basename $aros_gcc_cc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10653,11 +11542,15 @@ else for as_dir in `dirname $aros_gcc_cc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10669,11 +11562,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10683,11 +11576,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10697,11 +11591,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10713,11 +11611,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10731,11 +11629,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cc" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cc", so it can be a program name with args. set dummy $aros_kernel_cc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10745,11 +11644,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10761,11 +11664,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10798,11 +11701,12 @@ if test "$aros_kernel_cxx" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cxx", so it can be a program name with args. set dummy ${kernel_tool_prefix}cxx; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10812,11 +11716,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10828,11 +11736,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10847,11 +11755,12 @@ if test "$GCC" = "yes"; then aros_gcc_cxx=`$CC -print-prog-name=$ac_tool_cxx` # Extract the first word of "`basename $aros_gcc_[cxx]`", so it can be a program name with args. set dummy `basename $aros_gcc_cxx`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10861,11 +11770,15 @@ else for as_dir in `dirname $aros_gcc_cxx` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10877,11 +11790,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10891,11 +11804,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10905,11 +11819,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10921,11 +11839,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10939,11 +11857,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cxx" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cxx", so it can be a program name with args. set dummy $aros_kernel_cxx; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10953,11 +11872,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10969,11 +11892,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11001,11 +11924,12 @@ if test "$aros_kernel_ld" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ld", so it can be a program name with args. set dummy ${kernel_tool_prefix}ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11015,11 +11939,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11031,11 +11959,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11050,11 +11978,12 @@ if test "$GCC" = "yes"; then aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. set dummy `basename $aros_gcc_ld`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11064,11 +11993,15 @@ else for as_dir in `dirname $aros_gcc_ld` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11080,11 +12013,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11094,11 +12027,12 @@ if test "$aros_kernel_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11108,11 +12042,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11124,11 +12062,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11142,11 +12080,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ld" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ld", so it can be a program name with args. set dummy $aros_kernel_ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11156,11 +12095,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11172,11 +12115,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11204,11 +12147,12 @@ if test "$aros_kernel_as" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}as", so it can be a program name with args. set dummy ${kernel_tool_prefix}as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11218,11 +12162,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11234,11 +12182,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11253,11 +12201,12 @@ if test "$GCC" = "yes"; then aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. set dummy `basename $aros_gcc_as`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11267,11 +12216,15 @@ else for as_dir in `dirname $aros_gcc_as` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11283,11 +12236,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11297,11 +12250,12 @@ if test "$aros_kernel_as" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11311,11 +12265,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11327,11 +12285,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11345,11 +12303,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_as" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_as", so it can be a program name with args. set dummy $aros_kernel_as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11359,11 +12318,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11375,11 +12338,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11412,11 +12375,12 @@ if test "$aros_kernel_ar" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ar", so it can be a program name with args. set dummy ${kernel_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11426,11 +12390,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11442,11 +12410,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11461,11 +12429,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11475,11 +12444,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11491,11 +12464,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11505,11 +12478,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11519,11 +12493,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11535,11 +12513,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11553,11 +12531,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ar" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ar", so it can be a program name with args. set dummy $aros_kernel_ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11567,11 +12546,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11583,11 +12566,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11619,11 +12602,12 @@ if test "$aros_kernel_ranlib" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ranlib", so it can be a program name with args. set dummy ${kernel_tool_prefix}ranlib; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11633,11 +12617,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11649,11 +12637,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11668,11 +12656,12 @@ if test "$GCC" = "yes"; then aros_gcc_ranlib=`$CC -print-prog-name=$ac_tool_ranlib` # Extract the first word of "`basename $aros_gcc_[ranlib]`", so it can be a program name with args. set dummy `basename $aros_gcc_ranlib`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11682,11 +12671,15 @@ else for as_dir in `dirname $aros_gcc_ranlib` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11698,11 +12691,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11712,11 +12705,12 @@ if test "$aros_kernel_ranlib" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11726,11 +12720,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11742,11 +12740,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11760,11 +12758,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ranlib" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ranlib", so it can be a program name with args. set dummy $aros_kernel_ranlib; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11774,11 +12773,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11790,11 +12793,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11822,11 +12825,12 @@ if test "$aros_kernel_nm" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}nm", so it can be a program name with args. set dummy ${kernel_tool_prefix}nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11836,11 +12840,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11852,11 +12860,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11871,11 +12879,12 @@ if test "$GCC" = "yes"; then aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. set dummy `basename $aros_gcc_nm`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11885,11 +12894,15 @@ else for as_dir in `dirname $aros_gcc_nm` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11901,11 +12914,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11915,11 +12928,12 @@ if test "$aros_kernel_nm" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11929,11 +12943,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11945,11 +12963,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11963,11 +12981,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_nm" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_nm", so it can be a program name with args. set dummy $aros_kernel_nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11977,11 +12996,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11993,11 +13016,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12019,11 +13042,12 @@ if test "$aros_kernel_strip" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}strip", so it can be a program name with args. set dummy ${kernel_tool_prefix}strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12033,11 +13057,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12049,11 +13077,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12068,11 +13096,12 @@ if test "$GCC" = "yes"; then aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. set dummy `basename $aros_gcc_strip`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12082,11 +13111,15 @@ else for as_dir in `dirname $aros_gcc_strip` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12098,11 +13131,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12112,11 +13145,12 @@ if test "$aros_kernel_strip" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12126,11 +13160,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12142,11 +13180,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12160,11 +13198,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_strip" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_strip", so it can be a program name with args. set dummy $aros_kernel_strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12174,11 +13213,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12190,11 +13233,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12226,11 +13269,12 @@ if test "$aros_kernel_objcopy" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}objcopy", so it can be a program name with args. set dummy ${kernel_tool_prefix}objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12240,11 +13284,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12256,11 +13304,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12275,11 +13323,12 @@ if test "$GCC" = "yes"; then aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. set dummy `basename $aros_gcc_objcopy`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12289,11 +13338,15 @@ else for as_dir in `dirname $aros_gcc_objcopy` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12305,11 +13358,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12319,11 +13372,12 @@ if test "$aros_kernel_objcopy" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12333,11 +13387,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12349,11 +13407,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12367,11 +13425,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_objcopy" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_objcopy", so it can be a program name with args. set dummy $aros_kernel_objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12381,11 +13440,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12397,11 +13460,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12419,11 +13482,12 @@ if test "$aros_kernel_objdump" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}objdump", so it can be a program name with args. set dummy ${kernel_tool_prefix}objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12433,11 +13497,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12449,11 +13517,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12468,11 +13536,12 @@ if test "$GCC" = "yes"; then aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. set dummy `basename $aros_gcc_objdump`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12482,11 +13551,15 @@ else for as_dir in `dirname $aros_gcc_objdump` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12498,11 +13571,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12512,11 +13585,12 @@ if test "$aros_kernel_objdump" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12526,11 +13600,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12542,11 +13620,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12560,11 +13638,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_objdump" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_objdump", so it can be a program name with args. set dummy $aros_kernel_objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12574,11 +13653,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12590,11 +13673,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12626,16 +13709,16 @@ fi fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which target tools to use" >&5 -$as_echo_n "checking which target tools to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which target tools to use" >&5 +printf %s "checking which target tools to use... " >&6; } if test "$aros_target_toolchain" = "yes"; then if test "$aros_toolchain" = "llvm" ; then msg_result="llvm" else msg_result=$target_tool_prefix fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } # We are building AROS crosstools tmp_tool_prefix="$AROS_CROSSTOOLSDIR/${target_tool_prefix}" orig_target_cc="${tmp_tool_prefix}${toolchain_c_compiler}${target_tool_version}" @@ -12659,19 +13742,20 @@ else aros_tool_prefix="${elf_tool_prefix}" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 -$as_echo "$aros_tool_prefix" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +printf "%s\n" "$aros_tool_prefix" >&6; } # We are *not* building AROS crosstools - use the AROS or ELF tools if test "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}cpp", so it can be a program name with args. set dummy ${target_tool_prefix}cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12681,11 +13765,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12697,11 +13785,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12716,11 +13804,12 @@ if test "$GCC" = "yes"; then aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. set dummy `basename $aros_gcc_cpp`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12730,11 +13819,15 @@ else for as_dir in `dirname $aros_gcc_cpp` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12746,11 +13839,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12760,11 +13853,12 @@ if test "$orig_target_cpp" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12774,11 +13868,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12790,11 +13888,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12808,11 +13906,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12822,11 +13921,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12838,11 +13941,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12864,11 +13967,12 @@ if test "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" = ""; if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. set dummy ${target_tool_prefix}gcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12878,11 +13982,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12894,11 +14002,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12913,11 +14021,12 @@ if test "$GCC" = "yes"; then aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. set dummy `basename $aros_gcc_gcc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12927,11 +14036,15 @@ else for as_dir in `dirname $aros_gcc_gcc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12943,11 +14056,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12957,11 +14070,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12971,11 +14085,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12987,11 +14105,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13005,11 +14123,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -13019,11 +14138,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13035,11 +14158,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13061,11 +14184,12 @@ if test "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" = " if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}g++", so it can be a program name with args. set dummy ${target_tool_prefix}g++; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13075,11 +14199,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13091,11 +14219,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13110,11 +14238,12 @@ if test "$GCC" = "yes"; then aros_gcc_g++=`$CC -print-prog-name=$ac_tool_g++` # Extract the first word of "`basename $aros_gcc_[g++]`", so it can be a program name with args. set dummy `basename $aros_gcc_g++`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13124,11 +14253,15 @@ else for as_dir in `dirname $aros_gcc_g++` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13140,11 +14273,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13154,11 +14287,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13168,11 +14302,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13184,11 +14322,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13202,11 +14340,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13216,11 +14355,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13232,11 +14375,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13258,11 +14401,12 @@ if test "${aros_tool_prefix}${toolchain_ld}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. set dummy ${target_tool_prefix}gcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13272,11 +14416,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13288,11 +14436,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13307,11 +14455,12 @@ if test "$GCC" = "yes"; then aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. set dummy `basename $aros_gcc_gcc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13321,11 +14470,15 @@ else for as_dir in `dirname $aros_gcc_gcc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13337,11 +14490,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13351,11 +14504,12 @@ if test "$orig_target_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13365,11 +14519,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13381,11 +14539,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13399,11 +14557,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ld}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ld}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ld}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13413,11 +14572,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13429,11 +14592,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13455,11 +14618,12 @@ if test "aros_tool_prefix}${toolchain_as}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}as", so it can be a program name with args. set dummy ${target_tool_prefix}as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13469,11 +14633,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13485,11 +14653,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13504,11 +14672,12 @@ if test "$GCC" = "yes"; then aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. set dummy `basename $aros_gcc_as`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13518,11 +14687,15 @@ else for as_dir in `dirname $aros_gcc_as` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13534,11 +14707,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13548,11 +14721,12 @@ if test "$orig_target_as" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13562,11 +14736,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13578,11 +14756,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13596,11 +14774,12 @@ else ac_tool_optarg=`expr "Xaros_tool_prefix}${toolchain_as}" : '[^ ]* \(.*\)'` # Extract the first word of "aros_tool_prefix}${toolchain_as}", so it can be a program name with args. set dummy aros_tool_prefix}${toolchain_as}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13610,11 +14789,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13626,11 +14809,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13652,11 +14835,12 @@ if test "${aros_tool_prefix}${toolchain_ar}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. set dummy ${target_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13666,11 +14850,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13682,11 +14870,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13701,11 +14889,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13715,11 +14904,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13731,11 +14924,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13745,11 +14938,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13759,11 +14953,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13775,11 +14973,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13793,11 +14991,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ar}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ar}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ar}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13807,11 +15006,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13823,11 +15026,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13849,11 +15052,12 @@ if test "${aros_tool_prefix}${toolchain_ranlib}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. set dummy ${target_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13863,11 +15067,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13879,11 +15087,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13898,11 +15106,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13912,11 +15121,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13928,11 +15141,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13942,11 +15155,12 @@ if test "$orig_target_ranlib" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13956,11 +15170,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13972,11 +15190,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13990,11 +15208,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ranlib}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ranlib}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ranlib}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -14004,11 +15223,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14020,11 +15243,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14046,11 +15269,12 @@ if test "${aros_tool_prefix}${toolchain_nm}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}nm", so it can be a program name with args. set dummy ${target_tool_prefix}nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14060,11 +15284,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14076,11 +15304,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14095,11 +15323,12 @@ if test "$GCC" = "yes"; then aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. set dummy `basename $aros_gcc_nm`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14109,11 +15338,15 @@ else for as_dir in `dirname $aros_gcc_nm` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14125,11 +15358,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14139,11 +15372,12 @@ if test "$orig_target_nm" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14153,11 +15387,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14169,11 +15407,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14187,11 +15425,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_nm}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_nm}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_nm}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14201,11 +15440,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14217,11 +15460,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14244,11 +15487,12 @@ if test "${aros_tool_prefix}${toolchain_strip}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}strip", so it can be a program name with args. set dummy ${target_tool_prefix}strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14258,11 +15502,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14274,11 +15522,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14293,11 +15541,12 @@ if test "$GCC" = "yes"; then aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. set dummy `basename $aros_gcc_strip`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14307,11 +15556,15 @@ else for as_dir in `dirname $aros_gcc_strip` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14323,11 +15576,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14337,11 +15590,12 @@ if test "$orig_target_strip" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14351,11 +15605,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14367,11 +15625,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14385,11 +15643,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_strip}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_strip}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_strip}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14399,11 +15658,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14415,11 +15678,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14444,11 +15707,12 @@ if test "${aros_tool_prefix}${toolchain_objcopy}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}objcopy", so it can be a program name with args. set dummy ${target_tool_prefix}objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14458,11 +15722,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14474,11 +15742,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14493,11 +15761,12 @@ if test "$GCC" = "yes"; then aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. set dummy `basename $aros_gcc_objcopy`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14507,11 +15776,15 @@ else for as_dir in `dirname $aros_gcc_objcopy` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14523,11 +15796,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14537,11 +15810,12 @@ if test "$orig_target_objcopy" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14551,11 +15825,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14567,11 +15845,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14585,11 +15863,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objcopy}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_objcopy}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_objcopy}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14599,11 +15878,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14615,11 +15898,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14641,11 +15924,12 @@ if test "${aros_tool_prefix}${toolchain_objdump}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}objdump", so it can be a program name with args. set dummy ${target_tool_prefix}objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14655,11 +15939,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14671,11 +15959,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14690,11 +15978,12 @@ if test "$GCC" = "yes"; then aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. set dummy `basename $aros_gcc_objdump`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14704,11 +15993,15 @@ else for as_dir in `dirname $aros_gcc_objdump` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14720,11 +16013,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14734,11 +16027,12 @@ if test "$orig_target_objdump" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14748,11 +16042,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14764,11 +16062,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14782,11 +16080,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objdump}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_objdump}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_objdump}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14796,11 +16095,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14812,11 +16115,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14879,11 +16182,12 @@ aros_target_mkdep="$aros_host_mkdep" if test "$rescomp" != ""; then # Extract the first word of "${kernel_tool_prefix}$rescomp", so it can be a program name with args. set dummy ${kernel_tool_prefix}$rescomp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_rescomp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_rescomp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_rescomp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_rescomp="$aros_kernel_rescomp" # Let the user override the test with a path. @@ -14893,11 +16197,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_rescomp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_rescomp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14909,11 +16217,11 @@ esac fi aros_kernel_rescomp=$ac_cv_path_aros_kernel_rescomp if test -n "$aros_kernel_rescomp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_rescomp" >&5 -$as_echo "$aros_kernel_rescomp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_rescomp" >&5 +printf "%s\n" "$aros_kernel_rescomp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -15019,9 +16327,10 @@ aros_plain_nm="${prefix}${toolchain_nm}" aros_plain_ar="${prefix}${toolchain_ar}" # Check whether --enable-includes was given. -if test "${enable_includes+set}" = set; then : +if test ${enable_includes+y} +then : enableval=$enable_includes; aros_target_incl=$enable_includes -else +else $as_nop aros_target_incl=no fi @@ -15044,8 +16353,8 @@ fi if test "x$test_kernel_cc" != "xno"; then if test "$aros_kernel_includes" != "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the kernel compiler's include path" >&5 -$as_echo_n "checking for the kernel compiler's include path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the kernel compiler's include path" >&5 +printf %s "checking for the kernel compiler's include path... " >&6; } if test "$aros_kernel_cc_includes" = "" ; then # Try to guess where the directory is. aros_kernel_cc_includes=`dirname \`${aros_kernel_cc} ${aros_kernel_cflags} -print-libgcc-file-name\``/include @@ -15087,16 +16396,16 @@ $as_echo_n "checking for the kernel compiler's include path... " >&6; } done fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc_includes" >&5 -$as_echo "$aros_kernel_cc_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc_includes" >&5 +printf "%s\n" "$aros_kernel_cc_includes" >&6; } # Adding -nostdinc to kernel includes as they are always used together. aros_kernel_includes="$aros_kernel_includes $aros_target_nostdinc_cflags -isystem $aros_kernel_cc_includes" fi fi if test "$crosstools" != "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the target compiler's include path" >&5 -$as_echo_n "checking for the target compiler's include path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the target compiler's include path" >&5 +printf %s "checking for the target compiler's include path... " >&6; } if test "$aros_target_cc_includes" = "" ; then #try to guess where the directory is aros_target_cc_includes=`dirname \`${orig_target_cc} -print-libgcc-file-name\``/include @@ -15127,8 +16436,8 @@ $as_echo_n "checking for the target compiler's include path... " >&6; } done fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cc_includes" >&5 -$as_echo "$aros_target_cc_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_cc_includes" >&5 +printf "%s\n" "$aros_target_cc_includes" >&6; } else # We do not know which c compiler version we are going to build and what we need to know # here is different for different versions so this will be set later during the @@ -15144,67 +16453,69 @@ fi save_cc="$CC" save_cflags="$CFLAGS" if test "x$test_kernel_cc" != "xno"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Testing kernel compiler..." >&5 -$as_echo "$as_me: Testing kernel compiler..." >&6;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing kernel compiler..." >&5 +printf "%s\n" "$as_me: Testing kernel compiler..." >&6;} CFLAGS="-iquote." kernel_cflags_iquote=$host_cflags_iquote kernel_cflags_iquote_end=$host_cflags_iquote_end if test "x-$cross_compiling" = "x-yes"; then CC="$aros_kernel_cc" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fno-stack-protector" >&5 -$as_echo_n "checking whether ${CC} accepts -fno-stack-protector... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fno-stack-protector" >&5 +printf %s "checking whether ${CC} accepts -fno-stack-protector... " >&6; } if test "x-$crosstools" != "x-yes"; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_stack_protector="yes" -else +else $as_nop use_no_stack_protector="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext else # we do know it is supported for the smallest version of gcc we are going to build # we assume it's also supported by later versions use_no_stack_protector=yes fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 -$as_echo "$use_no_stack_protector" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -iquote" >&5 -$as_echo_n "checking whether ${CC} accepts -iquote... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +printf "%s\n" "$use_no_stack_protector" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -iquote" >&5 +printf %s "checking whether ${CC} accepts -iquote... " >&6; } if test "x-$crosstools" != "x-yes"; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : has_iquote="yes" -else +else $as_nop has_iquote="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext else # we do know it is supported for the smallest version of gcc we are going to build # we assume it's also supported by later versions has_iquote=yes fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 -$as_echo "$has_iquote" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +printf "%s\n" "$has_iquote" >&6; } if test "x-$has_iquote" = "x-yes" ; then kernel_cflags_iquote=-iquote kernel_cflags_iquote_end= @@ -15226,28 +16537,29 @@ $as_echo "$has_iquote" >&6; } CFLAGS="$save_cflags -Wl,--hash-style=sysv" CC="$aros_kernel_cc" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -Wl,--hash-style=sysv" >&5 -$as_echo_n "checking whether ${CC} accepts -Wl,--hash-style=sysv... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -Wl,--hash-style=sysv" >&5 +printf %s "checking whether ${CC} accepts -Wl,--hash-style=sysv... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : use_hash_style="yes" -else +else $as_nop use_hash_style="no" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_hash_style" >&5 -$as_echo "$use_hash_style" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_hash_style" >&5 +printf "%s\n" "$use_hash_style" >&6; } if test "x-$use_hash_style" = "x-yes" ; then aros_kernel_cflags="$aros_kernel_cflags -Wl,--hash-style=sysv" fi @@ -15264,13 +16576,14 @@ CFLAGS="$save_cflags" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for default resolution of WBScreen" >&5 -$as_echo_n "checking for default resolution of WBScreen... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for default resolution of WBScreen" >&5 +printf %s "checking for default resolution of WBScreen... " >&6; } # Check whether --with-resolution was given. -if test "${with_resolution+set}" = set; then : +if test ${with_resolution+y} +then : withval=$with_resolution; resolution=$withval -else +else $as_nop resolution=none fi @@ -15286,67 +16599,70 @@ if test "$resolution" != "none" ; then aros_nominal_height=`echo $resolution | cut -d'x' -f2` aros_nominal_depth=`echo $resolution | cut -d'x' -f3` fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&5 -$as_echo "$aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&5 +printf "%s\n" "$aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&6; } aros_cv_nominal_width=$aros_nominal_width aros_cv_nominal_height=$aros_nominal_height aros_cv_nominal_depth=$aros_nominal_depth -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are compiling for non-vampires --with-nonvampire-support " >&5 -$as_echo_n "checking whether we are compiling for non-vampires --with-nonvampire-support ... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are compiling for non-vampires --with-nonvampire-support " >&5 +printf %s "checking whether we are compiling for non-vampires --with-nonvampire-support ... " >&6; } # Check whether --with-nonvampire-support was given. -if test "${with_nonvampire_support+set}" = set; then : +if test ${with_nonvampire_support+y} +then : withval=$with_nonvampire_support; nonvampire_support=$withval -else +else $as_nop nonvampire_support=none fi if test "$nonvampire_support" = "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Enabling nonvampire support" >&5 -$as_echo "Enabling nonvampire support" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Enabling nonvampire support" >&5 +printf "%s\n" "Enabling nonvampire support" >&6; } aros_config_cppflags="$aros_config_cppflags -DNONVAMPIRE" aros_config_cflags="$aros_config_cflags -DNONVAMPIRE" aros_kernel_cppflags="$aros_kernel_cppflags -DNONVAMPIRE" aros_kernel_cflags="$aros_kernel_cflags -DNONVAMPIRE" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 -$as_echo_n "checking Vampire card series: v2 or v4 ... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 +printf %s "checking Vampire card series: v2 or v4 ... " >&6; } # Check whether --with-vampirecard-series was given. -if test "${with_vampirecard_series+set}" = set; then : +if test ${with_vampirecard_series+y} +then : withval=$with_vampirecard_series; vampirecard_series="$withval" -else +else $as_nop vampirecard_Series="v4" fi if test "$vampirecard_series" = "v2" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v2 " >&5 -$as_echo "Vampire Card Series v2 " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v2 " >&5 +printf "%s\n" "Vampire Card Series v2 " >&6; } aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=2" aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=2" aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=2" aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=2" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v4 " >&5 -$as_echo "Vampire Card Series v4 " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v4 " >&5 +printf "%s\n" "Vampire Card Series v4 " >&6; } aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=4" aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=4" aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=4" aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=4" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether serial debug is enabled" >&5 -$as_echo_n "checking whether serial debug is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether serial debug is enabled" >&5 +printf %s "checking whether serial debug is enabled... " >&6; } # Check whether --with-serial-debug was given. -if test "${with_serial_debug+set}" = set; then : +if test ${with_serial_debug+y} +then : withval=$with_serial_debug; serial_debug=$withval -else +else $as_nop serial_debug=none fi @@ -15364,34 +16680,36 @@ else fi if test "$serial_debug" != "none" ; then aros_serial_debug=$serial_debug - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $serial_debug_forced on port $serial_debug" >&5 -$as_echo "$serial_debug_forced on port $serial_debug" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $serial_debug_forced on port $serial_debug" >&5 +printf "%s\n" "$serial_debug_forced on port $serial_debug" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether palm debug hack is enabled" >&5 -$as_echo_n "checking whether palm debug hack is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether palm debug hack is enabled" >&5 +printf %s "checking whether palm debug hack is enabled... " >&6; } # Check whether --enable-palm_debug_hack was given. -if test "${enable_palm_debug_hack+set}" = set; then : +if test ${enable_palm_debug_hack+y} +then : enableval=$enable_palm_debug_hack; palm_debug_hack="yes" -else +else $as_nop palm_debug_hack="no" fi if test "$palm_debug_hack" = "yes" ; then aros_palm_debug_hack="1" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $palm_debug_hack" >&5 -$as_echo "$palm_debug_hack" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $palm_debug_hack" >&5 +printf "%s\n" "$palm_debug_hack" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether usb3.0 code is enabled" >&5 -$as_echo_n "checking whether usb3.0 code is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether usb3.0 code is enabled" >&5 +printf %s "checking whether usb3.0 code is enabled... " >&6; } # Check whether --enable-usb30_code was given. -if test "${enable_usb30_code+set}" = set; then : +if test ${enable_usb30_code+y} +then : enableval=$enable_usb30_code; usb30_code="yes" -else +else $as_nop usb30_code="no" fi @@ -15399,39 +16717,41 @@ if test "$usb30_code" = "yes" ; then aros_config_cppflags="$aros_config_cppflags -DAROS_USB30_CODE" aros_kernel_cflags="$aros_kernel_cflags -DAROS_USB30_CODE" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $usb30_code" >&5 -$as_echo "$usb30_code" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $usb30_code" >&5 +printf "%s\n" "$usb30_code" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether nesting supervisor support is enabled" >&5 -$as_echo_n "checking whether nesting supervisor support is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether nesting supervisor support is enabled" >&5 +printf %s "checking whether nesting supervisor support is enabled... " >&6; } # Check whether --enable-nesting_supervisor was given. -if test "${enable_nesting_supervisor+set}" = set; then : +if test ${enable_nesting_supervisor+y} +then : enableval=$enable_nesting_supervisor; nesting_supervisor="yes" -else +else $as_nop nesting_supervisor="no" fi if test "$nesting_supervisor" = "yes" ; then aros_nesting_supervisor="1" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $nesting_supervisor" >&5 -$as_echo "$nesting_supervisor" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $nesting_supervisor" >&5 +printf "%s\n" "$nesting_supervisor" >&6; } if test "$aros_enable_mmu" = "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether MMU support is enabled" >&5 -$as_echo_n "checking whether MMU support is enabled... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether MMU support is enabled" >&5 +printf %s "checking whether MMU support is enabled... " >&6; } # Check whether --enable-mmu was given. -if test "${enable_mmu+set}" = set; then : +if test ${enable_mmu+y} +then : enableval=$enable_mmu; aros_enable_mmu=$enableval -else +else $as_nop aros_enable_mmu="yes" fi if test "$aros_enable_mmu" = "" ; then aros_enable_mmu="yes" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_enable_mmu" >&5 -$as_echo "$aros_enable_mmu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_enable_mmu" >&5 +printf "%s\n" "$aros_enable_mmu" >&6; } fi if test "$aros_enable_mmu" = "no" ; then aros_enable_mmu="0" @@ -15446,18 +16766,20 @@ if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" save_libs="$LIBS" LIBS="" ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" -if test "x$ac_cv_func_dlopen" = xyes; then : +if test "x$ac_cv_func_dlopen" = xyes +then : have_dl="yes" -else +else $as_nop have_dl="no" fi if test "x-$have_dl" = "x-no" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 -$as_echo_n "checking for dlopen in -ldl... " >&6; } -if ${ac_cv_lib_dl_dlopen+:} false; then : - $as_echo_n "(cached) " >&6 -else + { 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 : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15466,33 +16788,32 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char dlopen (); int -main () +main (void) { return dlopen (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_dl_dlopen=yes -else +else $as_nop ac_cv_lib_dl_dlopen=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -$as_echo "$ac_cv_lib_dl_dlopen" >&6; } -if test "x$ac_cv_lib_dl_dlopen" = xyes; then : +{ 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 : have_dl="yes" aros_host_ldflags="$aros_host_ldflags -ldl" -else +else $as_nop have_dl="no" fi @@ -15505,9 +16826,10 @@ fi # Check whether --enable-x11_hidd was given. -if test "${enable_x11_hidd+set}" = set; then : +if test ${enable_x11_hidd+y} +then : enableval=$enable_x11_hidd; x11_hidd="$enableval" -else +else $as_nop x11_hidd="$need_x11" fi @@ -15520,12 +16842,13 @@ fi if test "x-$x11_hidd" != "x-no" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 -$as_echo_n "checking for X... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for X" >&5 +printf %s "checking for X... " >&6; } # Check whether --with-x was given. -if test "${with_x+set}" = set; then : +if test ${with_x+y} +then : withval=$with_x; fi @@ -15536,12 +16859,41 @@ if test "x$with_x" = xno; then else case $x_includes,$x_libraries in #( *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #( - *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then : - $as_echo_n "(cached) " >&6 -else + *,NONE | NONE,*) if test ${ac_cv_have_x+y} +then : + printf %s "(cached) " >&6 +else $as_nop # One or both of the vars are not set, and there is no cached value. -ac_x_includes=no ac_x_libraries=no -rm -f -r conftest.dir +ac_x_includes=no +ac_x_libraries=no +# Do we need to do anything special at all? +ac_save_LIBS=$LIBS +LIBS="-lX11 $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main (void) +{ +XrmInitialize () + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO" +then : + # We can compile and link X programs with no special options. + ac_x_includes= + ac_x_libraries= +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +LIBS="$ac_save_LIBS" +# If that didn't work, only try xmkmf and file system searches +# for native compilation. +if test x"$ac_x_includes" = xno && test "$cross_compiling" = no +then : + rm -f -r conftest.dir if mkdir conftest.dir; then cd conftest.dir cat >Imakefile <<'_ACEOF' @@ -15580,7 +16932,7 @@ _ACEOF rm -f -r conftest.dir fi -# Standard set of common directories for X headers. + # Standard set of common directories for X headers. # Check X11 before X11Rn because it is often a symlink to the current release. ac_x_header_dirs=' /usr/X11/include @@ -15607,6 +16959,8 @@ ac_x_header_dirs=' /usr/local/include/X11R5 /usr/local/include/X11R4 +/opt/X11/include + /usr/X386/include /usr/x386/include /usr/XFree86/include/X11 @@ -15628,10 +16982,11 @@ if test "$ac_x_includes" = no; then /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # We can compile using X headers with no special include directory. ac_x_includes= -else +else $as_nop for ac_dir in $ac_x_header_dirs; do if test -r "$ac_dir/X11/Xlib.h"; then ac_x_includes=$ac_dir @@ -15652,20 +17007,21 @@ if test "$ac_x_libraries" = no; then /* end confdefs.h. */ #include int -main () +main (void) { XrmInitialize () ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : LIBS=$ac_save_LIBS # We can link X programs with no special library path. ac_x_libraries= -else +else $as_nop LIBS=$ac_save_LIBS -for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` +for ac_dir in `printf "%s\n" "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` do # Don't even attempt the hair of trying to link an X program! for ac_extension in a so sl dylib la dll; do @@ -15676,19 +17032,21 @@ do done done fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi # $ac_x_libraries = no +fi +# Record the results. case $ac_x_includes,$ac_x_libraries in #( - no,* | *,no | *\'*) + no,* | *,no | *\'*) : # Didn't find X, or a directory has "'" in its name. - ac_cv_have_x="have_x=no";; #( - *) + ac_cv_have_x="have_x=no" ;; #( + *) : # Record where we found X for the cache. ac_cv_have_x="have_x=yes\ ac_x_includes='$ac_x_includes'\ - ac_x_libraries='$ac_x_libraries'" + ac_x_libraries='$ac_x_libraries'" ;; esac fi ;; #( @@ -15698,8 +17056,8 @@ fi fi # $with_x != no if test "$have_x" != yes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 -$as_echo "$have_x" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 +printf "%s\n" "$have_x" >&6; } no_x=yes else # If each of the values was on the command line, it overrides each guess. @@ -15709,8 +17067,8 @@ else ac_cv_have_x="have_x=yes\ ac_x_includes='$x_includes'\ ac_x_libraries='$x_libraries'" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 -$as_echo "libraries $x_libraries, headers $x_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 +printf "%s\n" "libraries $x_libraries, headers $x_includes" >&6; } fi @@ -15739,9 +17097,10 @@ fi aros_host_x11_ldflags="$X_LIBS -lX11" # Check whether --enable-x11_shm was given. -if test "${enable_x11_shm+set}" = set; then : +if test ${enable_x11_shm+y} +then : enableval=$enable_x11_shm; x11_hidd_shm="$enableval" -else +else $as_nop x11_hidd_shm="auto" fi @@ -15754,30 +17113,20 @@ fi if test "x-$x11_hidd_shm" != "x-no" ; then - for ac_header in sys/ipc.h -do : - ac_fn_c_check_header_mongrel "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" -if test "x$ac_cv_header_sys_ipc_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_IPC_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ipc_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_IPC_H 1" >>confdefs.h fi -done - - for ac_header in sys/shm.h -do : - ac_fn_c_check_header_mongrel "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" -if test "x$ac_cv_header_sys_shm_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_SHM_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_shm_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_SHM_H 1" >>confdefs.h fi -done - if test "x-$ac_cv_header_sys_ipc_h" = "x-yes" -a "x-$ac_cv_header_sys_shm_h" = "x-yes" ; then @@ -15785,11 +17134,12 @@ done save_ldflags="$LDFLAGS" CFLAGS="$CFLAGS $X_CFLAGS" LDFLAGS="$LDFLAGS $X_LIBS" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XShmQueryExtension in -lXext" >&5 -$as_echo_n "checking for XShmQueryExtension in -lXext... " >&6; } -if ${ac_cv_lib_Xext_XShmQueryExtension+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XShmQueryExtension in -lXext" >&5 +printf %s "checking for XShmQueryExtension in -lXext... " >&6; } +if test ${ac_cv_lib_Xext_XShmQueryExtension+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lXext $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15798,30 +17148,29 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char XShmQueryExtension (); int -main () +main (void) { return XShmQueryExtension (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_Xext_XShmQueryExtension=yes -else +else $as_nop ac_cv_lib_Xext_XShmQueryExtension=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xext_XShmQueryExtension" >&5 -$as_echo "$ac_cv_lib_Xext_XShmQueryExtension" >&6; } -if test "x$ac_cv_lib_Xext_XShmQueryExtension" = xyes; then : +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xext_XShmQueryExtension" >&5 +printf "%s\n" "$ac_cv_lib_Xext_XShmQueryExtension" >&6; } +if test "x$ac_cv_lib_Xext_XShmQueryExtension" = xyes +then : have_xshm=yes fi @@ -15840,9 +17189,10 @@ fi # Check whether --enable-x11_vidmode was given. -if test "${enable_x11_vidmode+set}" = set; then : +if test ${enable_x11_vidmode+y} +then : enableval=$enable_x11_vidmode; x11_hidd_vidmode="$enableval" -else +else $as_nop x11_hidd_vidmode="auto" fi @@ -15859,11 +17209,12 @@ fi save_ldflags="$LDFLAGS" CFLAGS="$CFLAGS $X_CFLAGS" LDFLAGS="$LDFLAGS $X_LIBS" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryExtension in -lXxf86vm" >&5 -$as_echo_n "checking for XF86VidModeQueryExtension in -lXxf86vm... " >&6; } -if ${ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryExtension in -lXxf86vm" >&5 +printf %s "checking for XF86VidModeQueryExtension in -lXxf86vm... " >&6; } +if test ${ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lXxf86vm $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15872,30 +17223,29 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char XF86VidModeQueryExtension (); int -main () +main (void) { return XF86VidModeQueryExtension (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=yes -else +else $as_nop ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&5 -$as_echo "$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&6; } -if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" = xyes; then : +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&5 +printf "%s\n" "$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&6; } +if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" = xyes +then : have_vidmode=yes fi @@ -15914,9 +17264,10 @@ fi fi # Check whether --enable-sdl_hidd was given. -if test "${enable_sdl_hidd+set}" = set; then : +if test ${enable_sdl_hidd+y} +then : enableval=$enable_sdl_hidd; sdl_hidd="$enableval" -else +else $as_nop sdl_hidd="auto" fi @@ -15930,24 +17281,27 @@ fi SDL_VERSION=1.2.5 # Check whether --with-sdl-prefix was given. -if test "${with_sdl_prefix+set}" = set; then : +if test ${with_sdl_prefix+y} +then : withval=$with_sdl_prefix; sdl_prefix="$withval" -else +else $as_nop sdl_prefix="" fi # Check whether --with-sdl-exec-prefix was given. -if test "${with_sdl_exec_prefix+set}" = set; then : +if test ${with_sdl_exec_prefix+y} +then : withval=$with_sdl_exec_prefix; sdl_exec_prefix="$withval" -else +else $as_nop sdl_exec_prefix="" fi # Check whether --enable-sdltest was given. -if test "${enable_sdltest+set}" = set; then : +if test ${enable_sdltest+y} +then : enableval=$enable_sdltest; -else +else $as_nop enable_sdltest=yes fi @@ -15971,11 +17325,12 @@ fi fi # Extract the first word of "sdl-config", so it can be a program name with args. set dummy sdl-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_SDL_CONFIG+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SDL_CONFIG+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $SDL_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_SDL_CONFIG="$SDL_CONFIG" # Let the user override the test with a path. @@ -15985,11 +17340,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_SDL_CONFIG="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_SDL_CONFIG="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -16002,18 +17361,18 @@ esac fi SDL_CONFIG=$ac_cv_path_SDL_CONFIG if test -n "$SDL_CONFIG"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5 -$as_echo "$SDL_CONFIG" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5 +printf "%s\n" "$SDL_CONFIG" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi PATH="$as_save_PATH" min_sdl_version=$SDL_VERSION - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SDL - version >= $min_sdl_version" >&5 -$as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SDL - version >= $min_sdl_version" >&5 +printf %s "checking for SDL - version >= $min_sdl_version... " >&6; } no_sdl="" if test "$SDL_CONFIG" = "no" ; then no_sdl=yes @@ -16035,9 +17394,10 @@ $as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; } CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" LIBS="$LIBS $SDL_LIBS" rm -f conf.sdltest - if test "$cross_compiling" = yes; then : + if test "$cross_compiling" = yes +then : echo $ac_n "cross compiling; assumed OK... $ac_c" -else +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -16099,9 +17459,10 @@ int main (int argc, char *argv[]) _ACEOF -if ac_fn_c_try_run "$LINENO"; then : +if ac_fn_c_try_run "$LINENO" +then : -else +else $as_nop no_sdl=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ @@ -16114,12 +17475,12 @@ fi fi fi if test "x$no_sdl" = x ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } have_sdl="yes" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } if test "$SDL_CONFIG" = "no" ; then echo "*** The sdl-config script installed by SDL could not be found" echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in" @@ -16145,14 +17506,15 @@ int main(int argc, char *argv[]) #define main K_and_R_C_main int -main () +main (void) { return 0; ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding SDL or finding the wrong" echo "*** version of SDL. If it is not finding SDL, you'll need to set your" @@ -16162,13 +17524,13 @@ if ac_fn_c_try_link "$LINENO"; then : echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" -else +else $as_nop echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occured. This usually means SDL was incorrectly installed" echo "*** or that you have moved SDL since it was installed. In the latter case, you" echo "*** may want to edit the sdl-config script: $SDL_CONFIG" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext CFLAGS="$ac_save_CFLAGS" CXXFLAGS="$ac_save_CXXFLAGS" @@ -16200,12 +17562,13 @@ rm -f core conftest.err conftest.$ac_objext \ fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether building of dbus.library is enabled" >&5 -$as_echo_n "checking whether building of dbus.library is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether building of dbus.library is enabled" >&5 +printf %s "checking whether building of dbus.library is enabled... " >&6; } # Check whether --enable-dbus was given. -if test "${enable_dbus+set}" = set; then : +if test ${enable_dbus+y} +then : enableval=$enable_dbus; dbus="yes" -else +else $as_nop dbus="no" fi @@ -16218,8 +17581,8 @@ if test "$dbus" = "yes" ; then else ENABLE_DBUS=0 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dbus" >&5 -$as_echo "$dbus" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dbus" >&5 +printf "%s\n" "$dbus" >&6; } if test "$use_kernel_cc_wrapper" = "yes" ; then aros_kernel_cc="${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-${toolchain_c_compiler}" @@ -16228,21 +17591,21 @@ fi aros_kernel_cppflags=$aros_config_cppflags aros_optimization_cflags="$optimization_level" if test "$optimization" = "default"; then -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking default optimization level to use" >&5 -$as_echo_n "checking default optimization level to use... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization_level" >&5 -$as_echo "$optimization_level" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking default optimization level to use" >&5 +printf %s "checking default optimization level to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $optimization_level" >&5 +printf "%s\n" "$optimization_level" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking kernel optimization level to conserve space" >&5 -$as_echo_n "checking kernel optimization level to conserve space... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking kernel optimization level to conserve space" >&5 +printf %s "checking kernel optimization level to conserve space... " >&6; } if test "$kernel_optimization_level" = ""; then kernel_optimization_level=$optimization_level fi kernel_optimization_cflags="$kernel_optimization_level" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_optimization_level" >&5 -$as_echo "$kernel_optimization_level" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_optimization_level" >&5 +printf "%s\n" "$kernel_optimization_level" >&6; } if ! test "$gcc_default_cpu" = "" ; then target_extra_cfg+="$export_newline""# ARM gcc default target$export_newline""GCC_DEFAULT_CPU := $gcc_default_cpu$export_newline""GCC_DEFAULT_FPU := $gcc_default_fpu$export_newline""GCC_DEFAULT_FLOAT_ABI := $gcc_default_float_abi$export_newline""GCC_DEFAULT_MODE := $gcc_default_mode$export_newline" @@ -16638,8 +18001,8 @@ _ACEOF case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$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) ;; #( @@ -16669,15 +18032,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; /^ac_cv_env_/b end t clear :clear - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 -$as_echo "$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 @@ -16691,8 +18054,8 @@ $as_echo "$as_me: updating cache $cache_file" >&6;} fi fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 -$as_echo "$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 @@ -16709,7 +18072,7 @@ U= for ac_i in : $LIBOBJS; 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=`$as_echo "$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" @@ -16725,8 +18088,8 @@ LTLIBOBJS=$ac_ltlibobjs ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 -$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +{ 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 #! $SHELL @@ -16749,14 +18112,16 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : +as_nop=: +if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else +else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( @@ -16766,46 +18131,46 @@ esac fi + +# Reset variables that may have inherited troublesome values from +# the environment. + +# IFS needs to be set, to space, tab, and newline, in precisely that order. +# (If _AS_PATH_WALK were called with IFS unset, it would have the +# side effect of setting IFS to empty, thus disabling word splitting.) +# Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi +IFS=" "" $as_nl" + +PS1='$ ' +PS2='> ' +PS4='+ ' + +# Ensure predictable behavior from utilities with locale-dependent output. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# We cannot yet rely on "unset" to work, but we need these variables +# to be unset--not just set to an empty or harmless value--now, to +# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct +# also avoids known problems related to "unset" and subshell syntax +# in other old shells (e.g. bash 2.01 and pdksh 5.2.14). +for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH +do eval test \${$as_var+y} \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done + +# Ensure that fds 0, 1, and 2 are open. +if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi +if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then +if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || @@ -16814,13 +18179,6 @@ if test "${PATH_SEPARATOR+set}" != set; then fi -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( @@ -16829,8 +18187,12 @@ case $0 in #(( for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS @@ -16842,30 +18204,10 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - $as_echo "$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 -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] @@ -16878,13 +18220,14 @@ 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 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - $as_echo "$as_me: error: $2" >&2 + printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error + # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. @@ -16911,18 +18254,20 @@ as_fn_unset () { eval $1=; unset $1;} } as_unset=as_fn_unset + # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null +then : eval 'as_fn_append () { eval $1+=\$2 }' -else +else $as_nop as_fn_append () { eval $1=\$$1\$2 @@ -16934,12 +18279,13 @@ fi # as_fn_append # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null +then : eval 'as_fn_arith () { as_val=$(( $* )) }' -else +else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` @@ -16970,7 +18316,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | +printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -16992,6 +18338,10 @@ 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*) @@ -17005,6 +18355,12 @@ case `echo -n x` in #((((( 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_echo='printf %s\n' +as_echo_n='printf %s' + rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -17046,7 +18402,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`$as_echo "$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" @@ -17055,7 +18411,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | +printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -17118,7 +18474,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # values after options handling. ac_log=" This file was extended by $as_me, which was -generated by GNU Autoconf 2.69. Invocation command line was +generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -17180,14 +18536,16 @@ $config_commands Report bugs to the package provider." _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="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ config.status -configured by $0, generated by GNU Autoconf 2.69, +configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" -Copyright (C) 2012 Free Software Foundation, Inc. +Copyright (C) 2021 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -17224,15 +18582,15 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - $as_echo "$ac_cs_version"; exit ;; + printf "%s\n" "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) - $as_echo "$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=`$as_echo "$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'" @@ -17240,7 +18598,7 @@ do --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`$as_echo "$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;; @@ -17249,7 +18607,7 @@ do as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) - $as_echo "$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=: ;; @@ -17277,7 +18635,7 @@ 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 - \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" @@ -17291,7 +18649,7 @@ exec 5>>config.log sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX - $as_echo "$ac_log" + printf "%s\n" "$ac_log" } >&5 _ACEOF @@ -17384,9 +18742,9 @@ done # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files - test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers - test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands + test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files + test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers + test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree @@ -17722,7 +19080,7 @@ do esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac - case $ac_f in *\'*) ac_f=`$as_echo "$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 @@ -17730,17 +19088,17 @@ do # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` - $as_echo "$*" | 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" - { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 -$as_echo "$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=`$as_echo "$configure_input" | + ac_sed_conf_input=`printf "%s\n" "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac @@ -17757,7 +19115,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$ac_file" | +printf "%s\n" X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -17781,9 +19139,9 @@ $as_echo X"$ac_file" | case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`$as_echo "$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=`$as_echo "$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/ ;; @@ -17836,8 +19194,8 @@ ac_sed_dataroot=' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -$as_echo "$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 ac_datarootdir_hack=' @@ -17879,9 +19237,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"; } && - { $as_echo "$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 -$as_echo "$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" @@ -17897,27 +19255,27 @@ which seems to be undefined. Please make sure it is defined" >&2;} # if test x"$ac_file" != x-; then { - $as_echo "/* $configure_input */" \ + 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 -$as_echo "$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 - $as_echo "/* $configure_input */" \ + 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 ;; - :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 -$as_echo "$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 @@ -17992,8 +19350,8 @@ if test "$no_create" != yes; then $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 -$as_echo "$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 @@ -18006,3 +19364,4 @@ if test -n "$aros_shared_cflags" ; then echo "SHARED_AR := $aros_shared_ar" >> ${aros_hostcfg_dir}/host.cfg fi + diff --git a/configure~ b/configure~ new file mode 100755 index 00000000000..f257323fdd9 --- /dev/null +++ b/configure~ @@ -0,0 +1,18008 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69. +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +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 + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$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 + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +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 + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME= +PACKAGE_TARNAME= +PACKAGE_VERSION= +PACKAGE_STRING= +PACKAGE_BUGREPORT= +PACKAGE_URL= + +ac_unique_file="mmakefile" +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_header_list= +ac_subst_vars='LTLIBOBJS +config_prefs_set +aros_usb30_code +aros_host_sdl_libs +aros_host_sdl_cflags +aros_host_x11_ldflags +aros_host_x11_cflags +DO_VIDMODE_SUPPORT +DO_XSHM_SUPPORT +ENABLE_X11 +KERNEL_DBUS_INCLUDES +KERNEL_DBUS_KOBJ +DBUS_LIBFLAGS +DBUS_CFLAGS +ENABLE_DBUS +java_target +objc_target +target_binutils_version +gcc_target_cpu +ignore_undefined_symbols +aros_modules_debug +aros_stack_debug +aros_mungwall_debug +aros_debug +aros_android_antapk +aros_android_level +aros_ios_sdk +aros_ios_version +aros_ios_platform +aros_palm_debug_hack +gcc_default_mode +gcc_default_float_abi +gcc_default_fpu +gcc_default_cpu_tune +gcc_default_cpu +aros_nesting_supervisor +target_grub2_version +aros_enable_mmu +ENABLE_EXECSMP +PLATFORM_EXECSMP +aros_serial_debug +aros_dist_amigadate +aros_dist_date +aros_dist_version +aros_dist_name +aros_nominal_depth +aros_nominal_height +aros_nominal_width +pci_hidd_target +use_libatomic +crosstools_cxx_target +crosstools_target +aros_isa_flags +aros_isa_extra +aros_kernel_isa_flags +aros_optimization_cflags +aros_config_coverage +aros_config_lto +aros_target_strip_flags +aros_target_genmap +aros_debug_ldflags +aros_debug_aflags +aros_debug_cxxflags +aros_debug_cflags +aros_debug_cppflags +kernel_optimization_cflags +aros_kernel_ldflags +aros_kernel_objcflags +aros_kernel_includes +aros_kernel_cflags +aros_kernel_cppflags +aros_kernel_sysroot +aros_config_ldflags +aros_config_aflags +aros_config_cxxflags +aros_config_cflags +aros_config_cppflags +aros_nowarn_flags +aros_warn_flags +aros_shared_ldflags +aros_shared_aflags +aros_shared_cflags +aros_cxx_libs +aros_cxx_ldflags +aros_c_libs +spec_obj_format +aros_object_format +aros_shared_ld +aros_shared_default +aros_target_nm +aros_target_strip +aros_target_objcopy +aros_target_objdump +aros_target_cc_path +aros_target_cc_includes +aros_target_ld +aros_target_as +aros_target_cpp +aros_target_cxx +aros_target_cc +aros_plain_ar +aros_plain_nm +aros_target_ranlib +aros_target_ar +aros_target_suffix +aros_target_variant +aros_target_cpu_mode +aros_target_cpu +aros_target_family +aros_target_arch +aros_target_bootloader +aros_target_iconset +aros_target_guitheme +aros_target_options +target_extra_cfg +make_extra_targetcfg +make_extra_commands +aros_elf_translate +aros_tools_dir +aros_host_lib_suffix +aros_host_exe_suffix +aros_host_mkargs +aros_host_mkdep +aros_host_debug +aros_host_ldflags +gnu89_inline +aros_host_cxxflags +aros_host_cflags +aros_host_cppflags +aros_host_make +aros_host_ar +aros_host_cxx +aros_host_cc +aros_host_def_cc +aros_host_cpp +aros_host_cpu +aros_host_arch +aros_cc_pre +host_extra_cfg +ax_cv_flex_version +host_stat_h__unused_used +HOST_TOOLCHAIN_FAMILY +aros_amigaos_compliance +AROS_PORTSSRCDIR +AROS_CROSSTOOLSDIR +SRCDIR +AROS_BUILDDIR_UNIX +AROS_BUILDDIR +aros_build_host +aros_toolchain_ld +aros_target_toolchain +aros_flavour_uc +aros_flavour +aros_target_cpu_extra +aros_cpu +aros_arch +SDL_LIBS +SDL_CFLAGS +SDL_CONFIG +XMKMF +kernel_cflags_iquote_end +kernel_cflags_iquote +host_cflags_iquote_end +host_cflags_iquote +aros_toolchain +aros_target_nostdlib_ldflags +aros_target_detach_ldflags +aros_target_nix_ldflags +aros_target_nostartup_ldflags +aros_target_nostdinc_cflags +aros_kernel_rescomp +orig_target_objdump +orig_target_objcopy +orig_target_strip +orig_target_nm +orig_target_ranlib +orig_target_ar +orig_target_as +orig_target_ld +orig_target_cxx +orig_target_cc +orig_target_cpp +aros_kernel_objdump +aros_kernel_objcopy +aros_kernel_strip +aros_kernel_nm +aros_kernel_ranlib +aros_kernel_ar +aros_kernel_as +aros_kernel_ld +aros_kernel_cxx +aros_kernel_cc +aros_kernel_cpp +target_llvm_version +target_gcc_version +ant +android_tool +CCACHE +DISTCC +LIBOBJS +EGREP +GREP +CMP +TEST +IF +FOR +libpng_incdir +libpng_libextra +libpng +arosconfig_use_libpngconfig +pkgpyexecdir +pyexecdir +pkgpythondir +pythondir +PYTHON_PLATFORM +PYTHON_EXEC_PREFIX +PYTHON_PREFIX +PYTHON_VERSION +PYTHON +PATCH +CHMOD +SED +PPMTOILBM +PNGTOPNM +FLEX +BISON +CAT +NOP +UNIQ +SORT +TOUCH +MKDIR +ECHO +MV +CP +RM +aros_host_strip +aros_host_ranlib +RANLIB_BASE +aros_host_plain_ar +AR_BASE +aros_host_automake +aros_host_autoheader +aros_host_autoconf +aros_host_aclocal +aros_host_ld +LD_BASE +base_lld_name +MMAKE +AWK +CPP +ac_ct_CC +CFLAGS +CC +OBJEXT +EXEEXT +ac_ct_CXX +CPPFLAGS +LDFLAGS +CXXFLAGS +CXX +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +runstatedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +with_aros_prefs +with_c_compiler +with_cxx_compiler +enable_libpng_config +with_toolchain +enable_lto +enable_coverage +enable_build_type +enable_debug +enable_distcc +enable_ccache +with_kernel_gcc_version +with_optimization +with_paranoia +enable_target_variant +enable_dist_name +enable_dist_version +enable_dist_date +enable_dist_amigadate +with_xcode +with_sdk_version +with_sdk +with_ndk +with_ndk_version +with_apk_version +enable_amigaos_compliance +with_kernel_toolchain_prefix +with_elf_toolchain_prefix +with_aros_toolchain +enable_crosstools +with_aros_toolchain_install +with_binutils_version +with_gcc_version +with_llvm_version +enable_objc +enable_java +with_cpu +with_fpu +with_float +with_portssources +with_bootloader +with_iconset +with_theme +enable_includes +with_resolution +with_nonvampire_support +with_vampirecard_series +with_serial_debug +enable_palm_debug_hack +enable_usb30_code +enable_nesting_supervisor +enable_mmu +enable_x11_hidd +with_x +enable_x11_shm +enable_x11_vidmode +enable_sdl_hidd +with_sdl_prefix +with_sdl_exec_prefix +enable_sdltest +enable_dbus +' + ac_precious_vars='build_alias +host_alias +target_alias +CXX +CXXFLAGS +LDFLAGS +LIBS +CPPFLAGS +CCC +CC +CFLAGS +CPP +PYTHON +XMKMF' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +runstatedir='${localstatedir}/run' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -runstatedir | --runstatedir | --runstatedi | --runstated \ + | --runstate | --runstat | --runsta | --runst | --runs \ + | --run | --ru | --r) + ac_prev=runstatedir ;; + -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \ + | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \ + | --run=* | --ru=* | --r=*) + runstatedir=$ac_optarg ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir runstatedir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures this package to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/PACKAGE] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +X features: + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] +--disable-libpng-config disable libpng-config test and configuration + --enable-lto=yes|no Enable link time optimizations if the target + compiler supports them (default=no) + --enable-coverage=yes|no + Enable coverage instrumentation if the target + compiler supports it (default=no) + --enable-build-type=TYPE + Select the build type. Available types are: + personal, nightly, snapshot, milestone, release. Do + NOT use this option unless you know what you are + doing! (default=personal) + --enable-debug=list Enable different types of debug. Commas or + whitespaces can be used to separate the items in the + list. Available types of debug are: all, none, + messages, stack, mungwall, modules, symbols. If no + list is provided then "all" is assumed. + (default=none) + --enable-distcc Use distcc as a front end to the compiler + (default=no). + --enable-ccache Use ccache as a front end to the compiler + (default=no). + --enable-target-variant=NAME + Enable a specific target variant (default=none) + --enable-dist-name=NAME Enable a specific distro name (default=AROS) + --enable-dist-version=NAME + Enable a specific distro version (default=ABIv1) + --enable-dist-date=NAME Enable a specific distro date (default=xxxx-xx-xx) + --enable-dist-amigadate=NAME + Enable a specific distro name (default=xx.x.xxxx) + --enable-amigaos-compliance=VERSION + Enforce userspace AmigaOS compliance to a specific + KickStart version (default=none). + --disable-crosstools Do not build cross-compiler toolchain + --enable-objc Enable Objectve-C support (default=no) + --enable-java Enable Java support (default=no) + --enable-includes=dir Alternative system include directory + --enable-palm-debug-hack + Enable palm debug output hack in palm native + (default=no) + --enable-usb30-code Enable usb3.0 code (default=no) + --enable-nesting-supervisor + Enable nesting supervisor support in unix + (default=no) + --disable-mmu Disable MMU support (default=enabled) + --enable-x11-hidd build X11 hidd for hosted (default=auto) + --enable-x11-shm use X11 shared memory (default=auto) + --enable-x11-vidmode use X11 vidmode extension (default=auto) + --enable-sdl-hidd build SDL hidd for hosted (default=auto) + --disable-sdltest Do not try to compile and run a test SDL program + --enable-dbus Enable DBUS support via dbus.library (default=no) + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-aros-prefs=PREFSSET + Use the preferences from the set defined by PREFSSET + (defaults to AROS normal config, 'classic' provides + a config more like traditional workbench - and + better suited to weaker systems) + --with-c-compiler=VERSION + Use specified c compiler for building AROS + --with-cxx-compiler=VERSION + Use specified c++ compiler building AROS + --with-toolchain=family Which toolchain family to crosscompile with + (defaults to gnu) + --with-kernel-gcc-version=VERSION + Use gcc-VERSION for building bootstrap + --with-optimization=FLAGS + Use optimization flags FLAGS (e.g + --with-optimization=-O2). + --with-paranoia=(yes|no|FLAGS) + Specific compiler warning FLAGS to enable for + paranoia builds (default=-Wall -Werror) + --with-xcode=PATH Specify XCode path for iOS targets + (default=/Developer). + --with-sdk-version=VERSION + Use iOS SDK version VERSION (default=4.1). + --with-sdk=PATH Specify Android SDK path + (default=$default_android_sdk). + --with-ndk=PATH Specify Android NDK path (default=none). + --with-sdk-version=LEVEL + Use Android SDK for API LEVEL (default=12). + --with-ndk-version=LEVEL + Use Android NDK for API LEVEL (default=9). + --with-apk-version=(release|debug) + Which version of AROSBootstrap.apk to compile. + Release version needs key for signing, debug version + will only run in emulator. (default=release) + --with-kernel-toolchain-prefix=... + Specify crosscompile toolchain prefix for kernel + objects + --with-elf-toolchain-prefix=... + Specify crosscompile toolchain prefix to wrap for + AROS objects + --with-aros-toolchain=PREFIX + Specify prebuilt AROS toolchain. Use yes for default + name + --with-aros-toolchain-install=DIR + Where to install or search for cross tools binaries + --with-binutils-version=VERSION + Use binutils-VERSION for building AROS + --with-gcc-version=VERSION + Compile gcc-VERSION for AROS + --with-llvm-version=VERSION + Compile llvm-VERSION for AROS + --with-cpu= Specify minumum CPU (default=$gcc_default_cpu). + --with-fpu= Specify minumum FPU (default=$gcc_default_fpu). + --with-float= Specify floating point ABI + (default=$gcc_default_float_abi). + --with-portssources=DIR Where to download sourcecode for external ports + --with-bootloader=NAME Use a specific bootloader + --with-iconset=NAME Use a specific Icon-set (default=Gorilla). + --with-theme=NAME Use a specific GUI Theme + --with-resolution=XRESxYRESxDEPTH + Default resolution of the initial WorkbenchScreen + --with-nonvampire-support + Enable support for non-vampires (default=no) + --with-vampirecard-series=VERSION + Set for which series of vampire card the rom is to + be built (default=v4) + --with-serial-debug Enable serial debug output in native (default=no) + --with-x use the X Window System + --with-sdl-prefix=PFX Prefix where SDL is installed (optional) + --with-sdl-exec-prefix=PFX Exec prefix where SDL is installed (optional) + +Some influential environment variables: + CXX C++ compiler command + CXXFLAGS C++ compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CC C compiler command + CFLAGS C compiler flags + CPP C preprocessor + PYTHON the Python interpreter + XMKMF Path to xmkmf, Makefile generator for X Window System + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to the package provider. +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$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/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +configure +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$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 + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_c_try_link LINENO +# ----------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_link + +# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists, giving a warning if it cannot be compiled using +# the include files in INCLUDES and setting the cache variable VAR +# accordingly. +ac_fn_c_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval \${$3+:} false; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include <$2> +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_mongrel + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run + +# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists and can be compiled using the include files in +# INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_compile + +# ac_fn_c_check_member LINENO AGGR MEMBER VAR INCLUDES +# ---------------------------------------------------- +# Tries to find if the field MEMBER exists in type AGGR, after including +# INCLUDES, setting cache variable VAR accordingly. +ac_fn_c_check_member () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 +$as_echo_n "checking for $2.$3... " >&6; } +if eval \${$4+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$5 +int +main () +{ +static $2 ac_aggr; +if (ac_aggr.$3) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$4=yes" +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$5 +int +main () +{ +static $2 ac_aggr; +if (sizeof ac_aggr.$3) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$4=yes" +else + eval "$4=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$4 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_member + +# ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES +# --------------------------------------------- +# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR +# accordingly. +ac_fn_c_check_decl () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + as_decl_name=`echo $2|sed 's/ *(.*//'` + as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 +$as_echo_n "checking whether $as_decl_name is declared... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +#ifndef $as_decl_name +#ifdef __cplusplus + (void) $as_decl_use; +#else + (void) $as_decl_name; +#endif +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_decl + +# ac_fn_c_check_type LINENO TYPE VAR INCLUDES +# ------------------------------------------- +# Tests whether TYPE exists after having included INCLUDES, setting cache +# variable VAR accordingly. +ac_fn_c_check_type () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=no" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +if (sizeof ($2)) + return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +int +main () +{ +if (sizeof (($2))) + return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + eval "$3=yes" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_type + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by $as_me, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +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=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + 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_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$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=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$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 +done + +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 + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +as_fn_append ac_header_list " stdlib.h" +as_fn_append ac_header_list " unistd.h" +as_fn_append ac_header_list " sys/param.h" +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$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` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$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=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +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 + + + +ac_aux_dir= +for ac_dir in scripts/autoconf "$srcdir"/scripts/autoconf; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in scripts/autoconf \"$srcdir\"/scripts/autoconf" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + + +# Check what host we are running on. +# If a target is not suggested, we use this one. +# Note that what we call a target, Autoconf calls a host. +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + + +# Default versions for the gnu tools we build +default_toolchain_family=`cat ${srcdir}/config/toolchain_def` +default_gcc_version=`cat ${srcdir}/config/gcc_def` +exp_gcc_version=`cat ${srcdir}/config/gcc_exp` +default_binutils_version=`cat ${srcdir}/config/binutils_def` +default_llvm_version=`cat ${srcdir}/config/llvm_def` +exp_binutils_version=`cat ${srcdir}/config/binutils_exp` +default_grub2_version="2.04" +target_grub2_version=$default_grub2_version + +# The AROS target is slightly different to the normal GNU style +# format. We don't have the middle part, and we reverse the order +# of the $(CPU) and $(OS) bits. +# +# Don't strip the version of the target yet, it might be +# useful on some systems. + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AROS style target" >&5 +$as_echo_n "checking for AROS style target... " >&6; } + +if test "$target" = "NONE" ; then + target=$host_os-$host_cpu +else + if test "$target" = "" ; then + target=$host_os-$host_cpu + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target" >&5 +$as_echo "$target" >&6; } + +if test "$host_os" = "mingw32" ; then + PWDCMD="pwd -W" +fi + +# Don't know where else to put this... +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking building AROS in" >&5 +$as_echo_n "checking building AROS in... " >&6; } +AROS_BUILDDIR=`${PWDCMD-pwd}` +AROS_BUILDDIR_UNIX=${PWD} +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_BUILDDIR" >&5 +$as_echo "$AROS_BUILDDIR" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS source in" >&5 +$as_echo_n "checking AROS source in... " >&6; } +srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}` +SRCDIR=${srcpwd} +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SRCDIR" >&5 +$as_echo "$SRCDIR" >&6; } + +# Parse the target field into something useful. + +target_os=`echo $target | sed 's/^\([^-].*\)-\(.*\)$/\1/'` +target_cpu=`echo $target | sed 's/^\([^-].*\)-\(.*\)$/\2/'` + + +# Some debug output, to be removed again. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target system (debug output)" >&5 +$as_echo_n "checking for target system (debug output)... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_os" >&5 +$as_echo "$target_os" >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target cpu (debug output)" >&5 +$as_echo_n "checking for target cpu (debug output)... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_cpu" >&5 +$as_echo "$target_cpu" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which prefs set to use" >&5 +$as_echo_n "checking which prefs set to use... " >&6; } + +# Check whether --with-aros-prefs was given. +if test "${with_aros_prefs+set}" = set; then : + withval=$with_aros_prefs; config_prefs_set="$withval" +else + config_prefs_set="" +fi + +if test "$config_prefs_set" != "" ; then + msg_result=$config_prefs_set +else + msg_result="default" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +$as_echo "$msg_result" >&6; } + +aros_dist_name=AROS +aros_dist_version=ABIv1 +aros_dist_date=$(date +%Y-%m-%d) +aros_dist_amigadate=$(date +"%-d.%-m.%Y") + +aros_nominal_width=800 +aros_nominal_height=600 +aros_nominal_depth=4 + + +HOST_WANTS_X11= +HOST_WANTS_GLX= +HOST_WANTS_SDL= +HOST_WANTS_DBUS= +HOST_WANTS_DLOPEN= + +default_c_compilers="gcc clang cc" + +# Check whether --with-c-compiler was given. +if test "${with_c_compiler+set}" = set; then : + withval=$with_c_compiler; use_c_compiler="$withval" +else + use_c_compiler="" +fi + +if test "$use_c_compiler" = ""; then + host_c_compilers="$default_c_compilers" +else + host_c_compilers="$use_c_compiler" + CC=$use_c_compiler +fi + +default_cxx_compilers="g++ clang++ c++" + +# Check whether --with-cxx-compiler was given. +if test "${with_cxx_compiler+set}" = set; then : + withval=$with_cxx_compiler; use_cxx_compiler="$withval" +else + use_cxx_compiler="" +fi + +if test "$use_cxx_compiler" = ""; then + host_cxx_compilers="$default_cxx_compilers" +else + host_cxx_compilers="$use_cxx_compiler" + CXX=$use_cxx_compiler +fi + + +# The first step is to find the host binaries. +# Check for a compiler. +# Due to a bug in autoconf check for c++ compiler first. +# For mor info see, http://osdir.com/ml/bug-autoconf-gnu/2010-05/msg00001.html. +ac_ext=cpp +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 +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in ${host_cxx_compilers} + 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 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in ${host_cxx_compilers} +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$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; do + { { ac_try="$ac_compiler $ac_option >&5" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +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. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5 +$as_echo_n "checking whether the C++ compiler works... " >&6; } +ac_link_default=`$as_echo "$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.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$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'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$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 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5 +$as_echo_n "checking for C++ compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$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 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$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; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_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. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$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 + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C++ compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$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; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +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 + +CXX_BASE=$CXX +# Extract the first word of "$CXX", so it can be a program name with args. +set dummy $CXX; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $CXX in + [\\/]* | ?:[\\/]*) + ac_cv_path_CXX="$CXX" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CXX="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CXX=$ac_cv_path_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +ac_ext=c +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 +if test -n "$ac_tool_prefix"; then + for ac_prog in ${host_c_compilers} + 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 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in ${host_c_compilers} +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$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. +$as_echo "$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; do + { { ac_try="$ac_compiler $ac_option >&5" +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\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +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 + +CC_BASE=$CC +ac_ext=c +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 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +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 + +CPP_BASE=$CPP +# Extract the first word of "$CC", so it can be a program name with args. +set dummy $CC; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $CC in + [\\/]* | ?:[\\/]*) + ac_cv_path_CC="$CC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CC="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +CC=$ac_cv_path_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +aros_host_def_cc="$CC" + case $ac_cv_prog_cc_stdc in #( + no) : + ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #( + *) : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5 +$as_echo_n "checking for $CC option to accept ISO C99... " >&6; } +if ${ac_cv_prog_cc_c99+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c99=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include +#include + +// Check varargs macros. These examples are taken from C99 6.10.3.5. +#define debug(...) fprintf (stderr, __VA_ARGS__) +#define showlist(...) puts (#__VA_ARGS__) +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) +static void +test_varargs_macros (void) +{ + int x = 1234; + int y = 5678; + debug ("Flag"); + debug ("X = %d\n", x); + showlist (The first, second, and third items.); + report (x>y, "x is %d but y is %d", x, y); +} + +// Check long long types. +#define BIG64 18446744073709551615ull +#define BIG32 4294967295ul +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) +#if !BIG_OK + your preprocessor is broken; +#endif +#if BIG_OK +#else + your preprocessor is broken; +#endif +static long long int bignum = -9223372036854775807LL; +static unsigned long long int ubignum = BIG64; + +struct incomplete_array +{ + int datasize; + double data[]; +}; + +struct named_init { + int number; + const wchar_t *name; + double average; +}; + +typedef const char *ccp; + +static inline int +test_restrict (ccp restrict text) +{ + // See if C++-style comments work. + // Iterate through items via the restricted pointer. + // Also check for declarations in for loops. + for (unsigned int i = 0; *(text+i) != '\0'; ++i) + continue; + return 0; +} + +// Check varargs and va_copy. +static void +test_varargs (const char *format, ...) +{ + va_list args; + va_start (args, format); + va_list args_copy; + va_copy (args_copy, args); + + const char *str; + int number; + float fnumber; + + while (*format) + { + switch (*format++) + { + case 's': // string + str = va_arg (args_copy, const char *); + break; + case 'd': // int + number = va_arg (args_copy, int); + break; + case 'f': // float + fnumber = va_arg (args_copy, double); + break; + default: + break; + } + } + va_end (args_copy); + va_end (args); +} + +int +main () +{ + + // Check bool. + _Bool success = false; + + // Check restrict. + if (test_restrict ("String literal") == 0) + success = true; + char *restrict newvar = "Another string"; + + // Check varargs. + 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)); + ia->datasize = 10; + for (int i = 0; i < ia->datasize; ++i) + ia->data[i] = i * 1.234; + + // Check named initializers. + struct named_init ni = { + .number = 34, + .name = L"Test wide string", + .average = 543.34343, + }; + + ni.number = 58; + + int dynamic_array[ni.number]; + dynamic_array[ni.number - 1] = 543; + + // work around unused variable warnings + return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' + || dynamic_array[ni.number - 1] != 543); + + ; + return 0; +} +_ACEOF +for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c99=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c99" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c99" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c99" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +$as_echo "$ac_cv_prog_cc_c99" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c99" != xno; then : + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 +else + ac_cv_prog_cc_stdc=no +fi + +fi + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5 +$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; } + if ${ac_cv_prog_cc_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +fi + + case $ac_cv_prog_cc_stdc in #( + no) : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; #( + '') : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; #( + *) : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5 +$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;; +esac + +ac_ext=c +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 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +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 + + +# detect the compiler version +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which toolchain family ${CC_BASE} belongs to" >&5 +$as_echo_n "checking which toolchain family ${CC_BASE} belongs to... " >&6; } +HOST_COMPILER_VERSION=`"$CC" --version 2>/dev/null` +if test x"$HOST_COMPILER_VERSION" = "x"; then + HOST_COMPILER_VERSION=`"$CC" --qversion 2>/dev/null` +fi +if test x"$HOST_COMPILER_VERSION" = "x"; then + HOST_COMPILER_VERSION=`"$CC" -V 2>/dev/null` +fi + +IS_SUN_COMPILER=`echo $HOST_COMPILER_VERSION | grep -i -c -E 'Sun C\+\+'` +if test "$IS_SUN_COMPILER" -ne "0"; then + HOST_TOOLCHAIN_PREFIX= + HOST_TOOLCHAIN_SUFFIX= + HOST_TOOLCHAIN_FAMILY=sun +fi +IS_LLVM_COMPILER=`echo $HOST_COMPILER_VERSION | grep -i -c -E 'LLVM|clang'` +if test "$IS_LLVM_COMPILER" -ne "0"; then + if test "$CC_BASE" != "gcc"; then + HOST_TOOLCHAIN_PREFIX=llvm- + HOST_TOOLCHAIN_SUFFIX="`echo $CC_BASE | sed -e \"s|clang||g\"`" + HOST_TOOLCHAIN_FAMILY=llvm + else + IS_GNU_COMPILER=1 + fi +fi +if test "x$IS_GNU_COMPILER" = "x"; then + IS_GNU_COMPILER=`echo $HOST_COMPILER_VERSION | grep -i -c -E 'gcc'` +fi +if test "$IS_GNU_COMPILER" -ne "0"; then + HOST_TOOLCHAIN_PREFIX= + HOST_TOOLCHAIN_SUFFIX= + HOST_TOOLCHAIN_FAMILY=gnu +fi +if test x"$HOST_TOOLCHAIN_FAMILY" = "x"; then + HOST_TOOLCHAIN_FAMILY=unknown +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOST_TOOLCHAIN_FAMILY" >&5 +$as_echo "$HOST_TOOLCHAIN_FAMILY" >&6; } + +# Check for a compatible awk +for ac_prog in gawk nawk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +req_avail=yes +if test "$AWK" = ""; then + req_avail=no +fi +if test "$AWK" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "gawk is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "mmake", so it can be a program name with args. +set dummy mmake; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MMAKE+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MMAKE"; then + ac_cv_prog_MMAKE="$MMAKE" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_MMAKE="mmake " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MMAKE=$ac_cv_prog_MMAKE +if test -n "$MMAKE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MMAKE" >&5 +$as_echo "$MMAKE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + +# Perform some default variable assignments. Note all of these will be +# Regenerated from the script, so there is no need to cache them. + +aros_build_host=$host +aros_host_cpp="$CPP" +aros_host_cc="$CC" +aros_host_cxx="$CXX" +base_ld_name=${HOST_TOOLCHAIN_PREFIX}ld${HOST_TOOLCHAIN_SUFFIX} +if test "$HOST_TOOLCHAIN_FAMILY" = "llvm"; then + for ac_prog in $base_ld_name ld.lld${HOST_TOOLCHAIN_SUFFIX} ld64.lld${HOST_TOOLCHAIN_SUFFIX} ld-link${HOST_TOOLCHAIN_SUFFIX}.exe ld${HOST_TOOLCHAIN_SUFFIX} +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_base_lld_name+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$base_lld_name"; then + ac_cv_prog_base_lld_name="$base_lld_name" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_base_lld_name="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +base_lld_name=$ac_cv_prog_base_lld_name +if test -n "$base_lld_name"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $base_lld_name" >&5 +$as_echo "$base_lld_name" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$base_lld_name" && break +done + + LD_BASE=$base_lld_name +else + # Extract the first word of "$base_ld_name", so it can be a program name with args. +set dummy $base_ld_name; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_LD_BASE+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LD_BASE"; then + ac_cv_prog_LD_BASE="$LD_BASE" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_LD_BASE="" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +LD_BASE=$ac_cv_prog_LD_BASE +if test -n "$LD_BASE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_BASE" >&5 +$as_echo "$LD_BASE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi + +if test "$LD_BASE" = ""; then + ac_tool_ld=ld +else + ac_tool_ld=$LD_BASE +fi +if test "$GCC" = "yes"; then + aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` + # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ld`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_host_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_host_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ld` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_host_ld=$ac_cv_path_aros_host_ld +if test -n "$aros_host_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +$as_echo "$aros_host_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_host_ld" = ""; then + for ac_prog in $ac_tool_ld +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_host_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_host_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_host_ld=$ac_cv_path_aros_host_ld +if test -n "$aros_host_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +$as_echo "$aros_host_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_host_ld" && break +done + +fi + +req_avail=yes +if test "$aros_host_ld" = ""; then + req_avail=no +fi +if test "$aros_host_ld" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ld is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +aros_host_make="make" +aros_host_cflags="$CFLAGS" +aros_host_cxxflags="$CXXFLAGS" +aros_host_cppflags="$CPPFLAGS" +aros_host_ldflags="$LDFLAGS" +aros_host_debug="-g -O0" +aros_host_mkdep="\$(SRCDIR)/scripts/mkdep" +aros_host_mkargs="--no-print-directory" +aros_host_exe_suffix="$EXEEXT" +aros_host_lib_suffix="" + +# Ignore all compliance, AROS ROMs = 0 +# KickStart v1.0 = 30 +# KickStart v1.3 = 34 +# KickStart v2.0 = 37 +# KickStart v3.0 = 39 +# KickStart v3.1 = 40 +# AmigaOS v3.5 = 44 +aros_amigaos_compliance=0 + +for ac_prog in aclocal aclocal19 aclocal-1.9 +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_aros_host_aclocal+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$aros_host_aclocal"; then + ac_cv_prog_aros_host_aclocal="$aros_host_aclocal" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_aclocal="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +aros_host_aclocal=$ac_cv_prog_aros_host_aclocal +if test -n "$aros_host_aclocal"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_aclocal" >&5 +$as_echo "$aros_host_aclocal" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_host_aclocal" && break +done + +for ac_prog in autoconf autoconf259 autoconf253 +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_aros_host_autoconf+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$aros_host_autoconf"; then + ac_cv_prog_aros_host_autoconf="$aros_host_autoconf" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_autoconf="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +aros_host_autoconf=$ac_cv_prog_aros_host_autoconf +if test -n "$aros_host_autoconf"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoconf" >&5 +$as_echo "$aros_host_autoconf" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_host_autoconf" && break +done + +for ac_prog in autoheader autoheader259 autoheader253 +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_aros_host_autoheader+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$aros_host_autoheader"; then + ac_cv_prog_aros_host_autoheader="$aros_host_autoheader" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_autoheader="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +aros_host_autoheader=$ac_cv_prog_aros_host_autoheader +if test -n "$aros_host_autoheader"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoheader" >&5 +$as_echo "$aros_host_autoheader" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_host_autoheader" && break +done + +for ac_prog in automake automake19 automake-1.9 +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_aros_host_automake+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$aros_host_automake"; then + ac_cv_prog_aros_host_automake="$aros_host_automake" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_automake="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +aros_host_automake=$ac_cv_prog_aros_host_automake +if test -n "$aros_host_automake"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_automake" >&5 +$as_echo "$aros_host_automake" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_host_automake" && break +done + + +req_avail=yes +if test "$aros_host_aclocal" = ""; then + req_avail=no +fi +if test "$aros_host_aclocal" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "aclocal/aclocal19/aclocal-1.9 is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +req_avail=yes +if test "$aros_host_automake" = ""; then + req_avail=no +fi +if test "$aros_host_automake" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "automake/automake19/automake-1.9 is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +case "$aros_host_cc" in + *clang*) + aros_host_cc_pipe="" + ;; + *gcc*) + aros_host_cc_pipe="-pipe" + ;; + icc) + aros_host_cc_pipe="" + ;; + *) + aros_host_cc_pipe="" + ;; +esac + +aros_kernel_cc_includes="" +aros_target_cc_includes="" +host_cc_elf=yes + +# ---------------------------------------------------------------------------------------- +# Host-specific defaults +# +# This is the main host configuration section. It is where the host +# can change the values of any variables it needs to change. We do +# not look at anything that compiles to the target yet, we'll get +# to that later. + +case "$host_os" in + aros*) + aros_host_arch="aros" + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *x86_64*) + aros_host_cpu="x86_64" + ;; + *powerpc*) + aros_host_cpu="ppc" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + linux*) + aros_host_arch="linux" + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + android_build_os="linux-x86" + android_tool="android" + default_android_sdk="/opt/android-sdk-linux_x86" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *x86_64*) + aros_host_cpu="x86_64" + ;; + *m68k*) + aros_host_cpu="m68k" + ;; + *powerpc*) + aros_host_cpu="ppc" + ;; + *arm*) + aros_host_cpu="arm" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + freebsd*) + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe -I/usr/local/include" + aros_host_make="gmake" + aros_host_arch="freebsd" + aros_host_cpu="i386" + + aros_host_ldflags="$aros_host_ldflags -L/usr/local/lib -liconv" + + case $host_os in + freebsd[234]*) + aros_object_format="elf_i386" + ;; + + *) + aros_object_format="elf_i386_fbsd" + ;; + esac + + ;; + + darwin*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for macOS SDK files" >&5 +$as_echo_n "checking for macOS SDK files... " >&6; } + LOC=$( xcode-select -p ) + if test $? != 0; then : + as_fn_error $? "XCode incorrectly configured! +please run 'xcode-select --install' before +re-running configure" "$LINENO" 5 +fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LOC" >&5 +$as_echo "$LOC" >&6; } + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + aros_host_arch="darwin" + host_cc_elf=no + if [ -z ${SED+x} ]; then SED="gsed"; fi + android_build_os="darwin-x86" + android_tool="android" + default_android_sdk="/android-sdk-mac_x86" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *x86_64*) + aros_host_cpu="x86_64" + ;; + *powerpc*) + aros_host_cpu="ppc" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + + aros_host_ldflags="$aros_host_ldflags -liconv" + + ;; + + dragonfly*) + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + aros_host_make="gmake" + aros_host_arch="dragonfly" + case $host_cpu in + *i?86*) + aros_host_cpu="i386" + ;; + *amd64*) + aros_host_cpu="x86_64" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + netbsd*) + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + aros_host_make="gmake" + aros_host_arch="netbsd" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *m68k*) + aros_host_cpu="m68k" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + aros_host_lib_suffix=".0.0" + ;; + + openbsd*) + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + aros_host_make="gmake" + aros_host_arch="openbsd" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + solaris*) + aros_host_arch="solaris" + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *sparc*) + aros_host_cpu="sparc" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + morphos*) + aros_host_arch="morphos" + aros_host_cpu="ppc" + host_cc_elf=no + ;; + + amiga*) + aros_host_arch="amiga" + host_cc_elf=no + SORT="/gg/bin/sort" + TEST="/gg/bin/test" + UNIQ="/gg/bin/uniq" + FOR="for" + TOUCH="/gg/bin/touch" + case "$host_cpu" in + *m68k*) + aros_host_cpu="m68k" + ;; + *powerpc*) + aros_host_cpu="ppc" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + cygwin*) + aros_host_arch="cygwin" + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + host_cc_elf=no + android_build_os="windows" + android_tool="android.bat" + default_android_sdk="/cygdrive/c/android-sdk-windows-1.6_r1" + + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + + mingw32*) + aros_host_arch="mingw32" + aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" + host_cc_elf=no + android_build_os="windows" + android_tool="android.bat" + default_android_sdk="/c/android-sdk-windows-1.6_r1" + + libpng_libextra="-lws2_32" + + case "$host_cpu" in + *i?86*) + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Windows native gcc target" >&5 +$as_echo_n "checking for Windows native gcc target... " >&6; } + host_cpu=`gcc -dumpmachine` + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_cpu" >&5 +$as_echo "$host_cpu" >&6; } + ;; + + esac + + case "$host_cpu" in + *i?86*) + aros_host_cpu="i386" + ;; + + mingw32*) + aros_host_cpu="i386" + ;; + + *x86_64*) + aros_host_cpu="x86_64" + aros_host_cflags="$aros_host_cflags -isystem /mingw/include" + ;; + + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + aros_host_cpu="$host_cpu" + ;; + esac + ;; + *) + as_fn_error $? "Unsupported host architecture $host" "$LINENO" 5 + ;; +esac + +base_ar_name=${HOST_TOOLCHAIN_PREFIX}ar${HOST_TOOLCHAIN_SUFFIX} +# Extract the first word of "$base_ar_name", so it can be a program name with args. +set dummy $base_ar_name; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR_BASE+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR_BASE"; then + ac_cv_prog_AR_BASE="$AR_BASE" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_BASE="$base_ar_name " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR_BASE=$ac_cv_prog_AR_BASE +if test -n "$AR_BASE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_BASE" >&5 +$as_echo "$AR_BASE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +aros_host_ar_flags="cr" +aros_host_cmd_ar="$AR_BASE $aros_host_ar_flags" +# Extract the first word of "$aros_host_cmd_ar", so it can be a program name with args. +set dummy $aros_host_cmd_ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_host_plain_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_host_plain_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_host_plain_ar="$aros_host_plain_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_plain_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_path_aros_host_plain_ar" && ac_cv_path_aros_host_plain_ar="$aros_host_cmd_ar " + ;; +esac +fi +aros_host_plain_ar=$ac_cv_path_aros_host_plain_ar +if test -n "$aros_host_plain_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_plain_ar" >&5 +$as_echo "$aros_host_plain_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +aros_host_ar=`echo $aros_host_cmd_ar | sed -e "s|$base_ar_name|$aros_host_plain_ar|g"` +req_avail=yes +if test "$aros_host_ar" = ""; then + req_avail=no +fi +if test "$aros_host_ar" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ar is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +base_ranlib_name=${HOST_TOOLCHAIN_PREFIX}ranlib${HOST_TOOLCHAIN_SUFFIX} +# Extract the first word of "$base_ranlib_name", so it can be a program name with args. +set dummy $base_ranlib_name; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB_BASE+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB_BASE"; then + ac_cv_prog_RANLIB_BASE="$RANLIB_BASE" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_BASE="$base_ranlib_name " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB_BASE=$ac_cv_prog_RANLIB_BASE +if test -n "$RANLIB_BASE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_BASE" >&5 +$as_echo "$RANLIB_BASE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +# Extract the first word of "$RANLIB_BASE", so it can be a program name with args. +set dummy $RANLIB_BASE; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_host_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_host_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_host_ranlib="$aros_host_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_path_aros_host_ranlib" && ac_cv_path_aros_host_ranlib="$RANLIB_BASE " + ;; +esac +fi +aros_host_ranlib=$ac_cv_path_aros_host_ranlib +if test -n "$aros_host_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ranlib" >&5 +$as_echo "$aros_host_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$aros_host_ranlib" = ""; then + req_avail=no +fi +if test "$aros_host_ranlib" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ranlib is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_aros_host_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$aros_host_strip"; then + ac_cv_prog_aros_host_strip="$aros_host_strip" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_host_strip="strip " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +aros_host_strip=$ac_cv_prog_aros_host_strip +if test -n "$aros_host_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_strip" >&5 +$as_echo "$aros_host_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$aros_host_strip" = ""; then + req_avail=no +fi +if test "$aros_host_strip" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "strip is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +# Extract the first word of "rm", so it can be a program name with args. +set dummy rm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RM"; then + ac_cv_prog_RM="$RM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_RM="rm -rf" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RM=$ac_cv_prog_RM +if test -n "$RM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 +$as_echo "$RM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$RM" = ""; then + req_avail=no +fi +if test "$RM" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "rm is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "cp", so it can be a program name with args. +set dummy cp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CP"; then + ac_cv_prog_CP="$CP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CP="cp " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CP=$ac_cv_prog_CP +if test -n "$CP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 +$as_echo "$CP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$CP" = ""; then + req_avail=no +fi +if test "$CP" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cp is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "mv", so it can be a program name with args. +set dummy mv; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MV+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MV"; then + ac_cv_prog_MV="$MV" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_MV="mv " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MV=$ac_cv_prog_MV +if test -n "$MV"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 +$as_echo "$MV" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$MV" = ""; then + req_avail=no +fi +if test "$MV" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "mv is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "echo", so it can be a program name with args. +set dummy echo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ECHO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ECHO"; then + ac_cv_prog_ECHO="$ECHO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_ECHO="echo " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ECHO=$ac_cv_prog_ECHO +if test -n "$ECHO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 +$as_echo "$ECHO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$ECHO" = ""; then + req_avail=no +fi +if test "$ECHO" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "echo is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "mkdir", so it can be a program name with args. +set dummy mkdir; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MKDIR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MKDIR"; then + ac_cv_prog_MKDIR="$MKDIR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_MKDIR="mkdir -p" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MKDIR=$ac_cv_prog_MKDIR +if test -n "$MKDIR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 +$as_echo "$MKDIR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$MKDIR" = ""; then + req_avail=no +fi +if test "$MKDIR" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "mkdir is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "touch", so it can be a program name with args. +set dummy touch; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_TOUCH+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$TOUCH"; then + ac_cv_prog_TOUCH="$TOUCH" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_TOUCH="touch " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +TOUCH=$ac_cv_prog_TOUCH +if test -n "$TOUCH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 +$as_echo "$TOUCH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$TOUCH" = ""; then + req_avail=no +fi +if test "$TOUCH" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "touch is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "sort", so it can be a program name with args. +set dummy sort; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_SORT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$SORT"; then + ac_cv_prog_SORT="$SORT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_SORT="sort " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +SORT=$ac_cv_prog_SORT +if test -n "$SORT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 +$as_echo "$SORT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$SORT" = ""; then + req_avail=no +fi +if test "$SORT" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "sort is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "uniq", so it can be a program name with args. +set dummy uniq; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_UNIQ+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$UNIQ"; then + ac_cv_prog_UNIQ="$UNIQ" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_UNIQ="uniq " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +UNIQ=$ac_cv_prog_UNIQ +if test -n "$UNIQ"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5 +$as_echo "$UNIQ" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$UNIQ" = ""; then + req_avail=no +fi +if test "$UNIQ" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "uniq is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "true", so it can be a program name with args. +set dummy true; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_NOP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NOP"; then + ac_cv_prog_NOP="$NOP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_NOP="true " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +NOP=$ac_cv_prog_NOP +if test -n "$NOP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NOP" >&5 +$as_echo "$NOP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$NOP" = ""; then + req_avail=no +fi +if test "$NOP" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "true is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "cat", so it can be a program name with args. +set dummy cat; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CAT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CAT"; then + ac_cv_prog_CAT="$CAT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CAT="cat " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CAT=$ac_cv_prog_CAT +if test -n "$CAT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 +$as_echo "$CAT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$CAT" = ""; then + req_avail=no +fi +if test "$CAT" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cat is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "bison", so it can be a program name with args. +set dummy bison; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_BISON+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$BISON"; then + ac_cv_prog_BISON="$BISON" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_BISON="bison " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +BISON=$ac_cv_prog_BISON +if test -n "$BISON"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5 +$as_echo "$BISON" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$BISON" = ""; then + req_avail=no +fi +if test "$BISON" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "bison is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "flex", so it can be a program name with args. +set dummy flex; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_FLEX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$FLEX"; then + ac_cv_prog_FLEX="$FLEX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_FLEX="flex " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +FLEX=$ac_cv_prog_FLEX +if test -n "$FLEX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5 +$as_echo "$FLEX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$FLEX" = ""; then + req_avail=no +fi +if test "$FLEX" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "flex is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking version of $FLEX" >&5 +$as_echo_n "checking version of $FLEX... " >&6; } +ax_cv_flex_version="`$FLEX --version | cut -d\" \" -f2`" +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_flex_version" >&5 +$as_echo "$ax_cv_flex_version" >&6; } +# Extract the first word of "pngtopnm", so it can be a program name with args. +set dummy pngtopnm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_PNGTOPNM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$PNGTOPNM"; then + ac_cv_prog_PNGTOPNM="$PNGTOPNM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_PNGTOPNM="pngtopnm " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +PNGTOPNM=$ac_cv_prog_PNGTOPNM +if test -n "$PNGTOPNM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PNGTOPNM" >&5 +$as_echo "$PNGTOPNM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$PNGTOPNM" = ""; then + req_avail=no +fi +if test "$PNGTOPNM" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "pngtopnm is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "ppmtoilbm", so it can be a program name with args. +set dummy ppmtoilbm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_PPMTOILBM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$PPMTOILBM"; then + ac_cv_prog_PPMTOILBM="$PPMTOILBM" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_PPMTOILBM="ppmtoilbm " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +PPMTOILBM=$ac_cv_prog_PPMTOILBM +if test -n "$PPMTOILBM"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PPMTOILBM" >&5 +$as_echo "$PPMTOILBM" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$PPMTOILBM" = ""; then + req_avail=no +fi +if test "$PPMTOILBM" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ppmtoilbm is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "sed", so it can be a program name with args. +set dummy sed; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$SED"; then + ac_cv_prog_SED="$SED" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_SED="sed " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +SED=$ac_cv_prog_SED +if test -n "$SED"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +$as_echo "$SED" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$SED" = ""; then + req_avail=no +fi +if test "$SED" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "sed is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "chmod", so it can be a program name with args. +set dummy chmod; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CHMOD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CHMOD"; then + ac_cv_prog_CHMOD="$CHMOD" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CHMOD="chmod " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CHMOD=$ac_cv_prog_CHMOD +if test -n "$CHMOD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 +$as_echo "$CHMOD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$CHMOD" = ""; then + req_avail=no +fi +if test "$CHMOD" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "chmod is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +# Extract the first word of "patch", so it can be a program name with args. +set dummy patch; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_PATCH+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$PATCH"; then + ac_cv_prog_PATCH="$PATCH" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_PATCH="patch " + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +PATCH=$ac_cv_prog_PATCH +if test -n "$PATCH"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5 +$as_echo "$PATCH" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +req_avail=yes +if test "$PATCH" = ""; then + req_avail=no +fi +if test "$PATCH" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "patch is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + + + + + + + if test -n "$PYTHON"; then + # If the user set $PYTHON, use it and don't search something else. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 3.0" >&5 +$as_echo_n "checking whether $PYTHON version is >= 3.0... " >&6; } + prog="import sys +# split strings by '.' and convert to numeric. Append some zeros +# because we need at least 4 digits for the hex conversion. +# map returns an iterator in Python 3.0 and a list in 2.x +minver = list(map(int, '3.0'.split('.'))) + [0, 0, 0] +minverhex = 0 +# xrange is not present in Python 3.0 and range returns an iterator +for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i] +sys.exit(sys.hexversion < minverhex)" + if { echo "$as_me:$LINENO: $PYTHON -c "$prog"" >&5 + ($PYTHON -c "$prog") >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "Python interpreter is too old" "$LINENO" 5 +fi + am_display_PYTHON=$PYTHON + else + # Otherwise, try each interpreter until we find one that satisfies + # VERSION. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 3.0" >&5 +$as_echo_n "checking for a Python interpreter with version >= 3.0... " >&6; } +if ${am_cv_pathless_PYTHON+:} false; then : + $as_echo_n "(cached) " >&6 +else + + for am_cv_pathless_PYTHON in python python2 python3 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do + test "$am_cv_pathless_PYTHON" = none && break + prog="import sys +# split strings by '.' and convert to numeric. Append some zeros +# because we need at least 4 digits for the hex conversion. +# map returns an iterator in Python 3.0 and a list in 2.x +minver = list(map(int, '3.0'.split('.'))) + [0, 0, 0] +minverhex = 0 +# xrange is not present in Python 3.0 and range returns an iterator +for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[i] +sys.exit(sys.hexversion < minverhex)" + if { echo "$as_me:$LINENO: $am_cv_pathless_PYTHON -c "$prog"" >&5 + ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); }; then : + break +fi + done +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 +$as_echo "$am_cv_pathless_PYTHON" >&6; } + # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON. + if test "$am_cv_pathless_PYTHON" = none; then + PYTHON=: + else + # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args. +set dummy $am_cv_pathless_PYTHON; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_PYTHON+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $PYTHON in + [\\/]* | ?:[\\/]*) + ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_PYTHON="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +PYTHON=$ac_cv_path_PYTHON +if test -n "$PYTHON"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 +$as_echo "$PYTHON" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi + am_display_PYTHON=$am_cv_pathless_PYTHON + fi + + + if test "$PYTHON" = :; then + as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 + else + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 +$as_echo_n "checking for $am_display_PYTHON version... " >&6; } +if ${am_cv_python_version+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[:3])"` +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 +$as_echo "$am_cv_python_version" >&6; } + PYTHON_VERSION=$am_cv_python_version + + + + PYTHON_PREFIX='${prefix}' + + PYTHON_EXEC_PREFIX='${exec_prefix}' + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 +$as_echo_n "checking for $am_display_PYTHON platform... " >&6; } +if ${am_cv_python_platform+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 +$as_echo "$am_cv_python_platform" >&6; } + PYTHON_PLATFORM=$am_cv_python_platform + + + # Just factor out some code duplication. + am_python_setup_sysconfig="\ +import sys +# Prefer sysconfig over distutils.sysconfig, for better compatibility +# with python 3.x. See automake bug#10227. +try: + import sysconfig +except ImportError: + can_use_sysconfig = 0 +else: + can_use_sysconfig = 1 +# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs: +# +try: + from platform import python_implementation + if python_implementation() == 'CPython' and sys.version[:3] == '2.7': + can_use_sysconfig = 0 +except ImportError: + pass" + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5 +$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; } +if ${am_cv_python_pythondir+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$prefix" = xNONE + then + am_py_prefix=$ac_default_prefix + else + am_py_prefix=$prefix + fi + am_cv_python_pythondir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) + am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 +$as_echo "$am_cv_python_pythondir" >&6; } + pythondir=$am_cv_python_pythondir + + + + pkgpythondir=\${pythondir}/$PACKAGE + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5 +$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; } +if ${am_cv_python_pyexecdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$exec_prefix" = xNONE + then + am_py_exec_prefix=$am_py_prefix + else + am_py_exec_prefix=$exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " +$am_python_setup_sysconfig +if can_use_sysconfig: + sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) +else: + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') +sys.stdout.write(sitedir)"` + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) + am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages + ;; + esac + ;; + esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 +$as_echo "$am_cv_python_pyexecdir" >&6; } + pyexecdir=$am_cv_python_pyexecdir + + + + pkgpyexecdir=\${pyexecdir}/$PACKAGE + + + + fi + + + +# Check whether --enable-libpng-config was given. +if test "${enable_libpng_config+set}" = set; then : + enableval=$enable_libpng_config; +fi + +if test "$enable_libpng_config" != "no"; then + # Extract the first word of "libpng-config", so it can be a program name with args. +set dummy libpng-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_arosconfig_use_libpngconfig+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$arosconfig_use_libpngconfig"; then + ac_cv_prog_arosconfig_use_libpngconfig="$arosconfig_use_libpngconfig" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_arosconfig_use_libpngconfig="yes" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_prog_arosconfig_use_libpngconfig" && ac_cv_prog_arosconfig_use_libpngconfig="no" +fi +fi +arosconfig_use_libpngconfig=$ac_cv_prog_arosconfig_use_libpngconfig +if test -n "$arosconfig_use_libpngconfig"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $arosconfig_use_libpngconfig" >&5 +$as_echo "$arosconfig_use_libpngconfig" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$arosconfig_use_libpngconfig" = "yes"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking libpng-config library" >&5 +$as_echo_n "checking libpng-config library... " >&6; } + libpng_incdir="`libpng-config --cflags`" + libpng_libextra="$libpng_libextra `libpng-config --ldflags`" + libpng="`libpng-config --libs`" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $libpng" >&5 +$as_echo "$libpng" >&6; } +else + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for png_read_png in -lpng" >&5 +$as_echo_n "checking for png_read_png in -lpng... " >&6; } +if ${ac_cv_lib_png_png_read_png+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lpng $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char png_read_png (); +int +main () +{ +return png_read_png (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_png_png_read_png=yes +else + ac_cv_lib_png_png_read_png=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_png_png_read_png" >&5 +$as_echo "$ac_cv_lib_png_png_read_png" >&6; } +if test "x$ac_cv_lib_png_png_read_png" = xyes; then : + libpng="-lpng" +else + libpng="no" +fi + + if test "$libpng_libextra" != ""; then + if test "$libpng" != "no"; then + libpng_libextra="$libpng_libextra $libpng" + fi + fi +fi +req_avail=yes +if test "$libpng" = ""; then + req_avail=no +fi +if test "$libpng" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "libpng is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + + + +FOR=for + +IF=if + +TEST=test + +CMP=cmp + + + +# Check for some includes for the X11 HIDD and the kernel + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '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 + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '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 + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in sys/ipc.h sys/shm.h \ + sys/mmap.h sys/mman.h sysexits.h \ + sys/statfs.h sys/statvfs.h sys/vfs.h sys/param.h \ + +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in sys/mount.h +do : + ac_fn_c_check_header_compile "$LINENO" "sys/mount.h" "ac_cv_header_sys_mount_h" "#include +" +if test "x$ac_cv_header_sys_mount_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_SYS_MOUNT_H 1 +_ACEOF + +fi + +done + +for ac_header in GL/glx.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "GL/glx.h" "ac_cv_header_GL_glx_h" "$ac_includes_default" +if test "x$ac_cv_header_GL_glx_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_GL_GLX_H 1 +_ACEOF + host_feature_glx=yes +else + host_feature_glx=no +fi + +done + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __unused conflicts with sys/stat.h" >&5 +$as_echo_n "checking if __unused conflicts with sys/stat.h... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #define __unused __attribute__((unused)) + #include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + host_stat_h__unused_used=no +else + host_stat_h__unused_used=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_stat_h__unused_used" >&5 +$as_echo "$host_stat_h__unused_used" >&6; } + +ac_header_dirent=no +for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do + as_ac_Header=`$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 +$as_echo_n "checking for $ac_hdr that defines DIR... " >&6; } +if eval \${$as_ac_Header+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include <$ac_hdr> + +int +main () +{ +if ((DIR *) 0) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$as_ac_Header=yes" +else + eval "$as_ac_Header=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$as_ac_Header + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 +_ACEOF + +ac_header_dirent=$ac_hdr; break +fi + +done +# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. +if test $ac_header_dirent = dirent.h; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +$as_echo_n "checking for library containing opendir... " >&6; } +if ${ac_cv_search_opendir+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_func_search_save_LIBS=$LIBS +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char opendir (); +int +main () +{ +return opendir (); + ; + return 0; +} +_ACEOF +for ac_lib in '' dir; do + if test -z "$ac_lib"; then + ac_res="none required" + else + ac_res=-l$ac_lib + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + fi + if ac_fn_c_try_link "$LINENO"; then : + ac_cv_search_opendir=$ac_res +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext + if ${ac_cv_search_opendir+:} false; then : + break +fi +done +if ${ac_cv_search_opendir+:} false; then : + +else + ac_cv_search_opendir=no +fi +rm conftest.$ac_ext +LIBS=$ac_func_search_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +$as_echo "$ac_cv_search_opendir" >&6; } +ac_res=$ac_cv_search_opendir +if test "$ac_res" != no; then : + test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + +fi + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +$as_echo_n "checking for library containing opendir... " >&6; } +if ${ac_cv_search_opendir+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_func_search_save_LIBS=$LIBS +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char opendir (); +int +main () +{ +return opendir (); + ; + return 0; +} +_ACEOF +for ac_lib in '' x; do + if test -z "$ac_lib"; then + ac_res="none required" + else + ac_res=-l$ac_lib + LIBS="-l$ac_lib $ac_func_search_save_LIBS" + fi + if ac_fn_c_try_link "$LINENO"; then : + ac_cv_search_opendir=$ac_res +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext + if ${ac_cv_search_opendir+:} false; then : + break +fi +done +if ${ac_cv_search_opendir+:} false; then : + +else + ac_cv_search_opendir=no +fi +rm conftest.$ac_ext +LIBS=$ac_func_search_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +$as_echo "$ac_cv_search_opendir" >&6; } +ac_res=$ac_cv_search_opendir +if test "$ac_res" != no; then : + test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + +fi + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 +$as_echo_n "checking whether stat file-mode macros are broken... " >&6; } +if ${ac_cv_header_stat_broken+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include + +#if defined S_ISBLK && defined S_IFDIR +extern char c1[S_ISBLK (S_IFDIR) ? -1 : 1]; +#endif + +#if defined S_ISBLK && defined S_IFCHR +extern char c2[S_ISBLK (S_IFCHR) ? -1 : 1]; +#endif + +#if defined S_ISLNK && defined S_IFREG +extern char c3[S_ISLNK (S_IFREG) ? -1 : 1]; +#endif + +#if defined S_ISSOCK && defined S_IFREG +extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; +#endif + +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stat_broken=no +else + ac_cv_header_stat_broken=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 +$as_echo "$ac_cv_header_stat_broken" >&6; } +if test $ac_cv_header_stat_broken = yes; then + +$as_echo "#define STAT_MACROS_BROKEN 1" >>confdefs.h + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 +$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } +if ${ac_cv_header_sys_wait_h+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#ifndef WEXITSTATUS +# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8) +#endif +#ifndef WIFEXITED +# define WIFEXITED(stat_val) (((stat_val) & 255) == 0) +#endif + +int +main () +{ + int s; + wait (&s); + s = WIFEXITED (s) ? WEXITSTATUS (s) : 1; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_sys_wait_h=yes +else + ac_cv_header_sys_wait_h=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 +$as_echo "$ac_cv_header_sys_wait_h" >&6; } +if test $ac_cv_header_sys_wait_h = yes; then + +$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5 +$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; } +if ${ac_cv_header_time+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include + +int +main () +{ +if ((struct tm *) 0) +return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_time=yes +else + ac_cv_header_time=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5 +$as_echo "$ac_cv_header_time" >&6; } +if test $ac_cv_header_time = yes; then + +$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h + +fi + +ac_fn_c_check_member "$LINENO" "struct stat" "st_blksize" "ac_cv_member_struct_stat_st_blksize" "$ac_includes_default" +if test "x$ac_cv_member_struct_stat_st_blksize" = xyes; then : + +cat >>confdefs.h <<_ACEOF +#define HAVE_STRUCT_STAT_ST_BLKSIZE 1 +_ACEOF + + +$as_echo "#define HAVE_ST_BLKSIZE 1" >>confdefs.h + +fi + + +ac_fn_c_check_member "$LINENO" "struct stat" "st_blocks" "ac_cv_member_struct_stat_st_blocks" "$ac_includes_default" +if test "x$ac_cv_member_struct_stat_st_blocks" = xyes; then : + +cat >>confdefs.h <<_ACEOF +#define HAVE_STRUCT_STAT_ST_BLOCKS 1 +_ACEOF + + +$as_echo "#define HAVE_ST_BLOCKS 1" >>confdefs.h + +else + case " $LIBOBJS " in + *" fileblocks.$ac_objext "* ) ;; + *) LIBOBJS="$LIBOBJS fileblocks.$ac_objext" + ;; +esac + +fi + + +ac_fn_c_check_member "$LINENO" "struct stat" "st_rdev" "ac_cv_member_struct_stat_st_rdev" "$ac_includes_default" +if test "x$ac_cv_member_struct_stat_st_rdev" = xyes; then : + +cat >>confdefs.h <<_ACEOF +#define HAVE_STRUCT_STAT_ST_RDEV 1 +_ACEOF + + +$as_echo "#define HAVE_ST_RDEV 1" >>confdefs.h + +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 +$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; } +if ${ac_cv_struct_tm+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include + +int +main () +{ +struct tm tm; + int *p = &tm.tm_sec; + return !p; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_struct_tm=time.h +else + ac_cv_struct_tm=sys/time.h +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 +$as_echo "$ac_cv_struct_tm" >&6; } +if test $ac_cv_struct_tm = sys/time.h; then + +$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h + +fi + +ac_fn_c_check_member "$LINENO" "struct tm" "tm_zone" "ac_cv_member_struct_tm_tm_zone" "#include +#include <$ac_cv_struct_tm> + +" +if test "x$ac_cv_member_struct_tm_tm_zone" = xyes; then : + +cat >>confdefs.h <<_ACEOF +#define HAVE_STRUCT_TM_TM_ZONE 1 +_ACEOF + + +fi + +if test "$ac_cv_member_struct_tm_tm_zone" = yes; then + +$as_echo "#define HAVE_TM_ZONE 1" >>confdefs.h + +else + ac_fn_c_check_decl "$LINENO" "tzname" "ac_cv_have_decl_tzname" "#include +" +if test "x$ac_cv_have_decl_tzname" = xyes; then : + ac_have_decl=1 +else + ac_have_decl=0 +fi + +cat >>confdefs.h <<_ACEOF +#define HAVE_DECL_TZNAME $ac_have_decl +_ACEOF + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tzname" >&5 +$as_echo_n "checking for tzname... " >&6; } +if ${ac_cv_var_tzname+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#if !HAVE_DECL_TZNAME +extern char *tzname[]; +#endif + +int +main () +{ +return tzname[0][0]; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_var_tzname=yes +else + ac_cv_var_tzname=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_var_tzname" >&5 +$as_echo "$ac_cv_var_tzname" >&6; } + if test $ac_cv_var_tzname = yes; then + +$as_echo "#define HAVE_TZNAME 1" >>confdefs.h + + fi +fi + +ac_fn_c_check_type "$LINENO" "off_t" "ac_cv_type_off_t" "$ac_includes_default" +if test "x$ac_cv_type_off_t" = xyes; then : + +else + +cat >>confdefs.h <<_ACEOF +#define off_t long int +_ACEOF + +fi + +ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" +if test "x$ac_cv_type_pid_t" = xyes; then : + +else + +cat >>confdefs.h <<_ACEOF +#define pid_t int +_ACEOF + +fi + +ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" +if test "x$ac_cv_type_size_t" = xyes; then : + +else + +cat >>confdefs.h <<_ACEOF +#define size_t unsigned int +_ACEOF + +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 +$as_echo_n "checking for uid_t in sys/types.h... " >&6; } +if ${ac_cv_type_uid_t+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "uid_t" >/dev/null 2>&1; then : + ac_cv_type_uid_t=yes +else + ac_cv_type_uid_t=no +fi +rm -f conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 +$as_echo "$ac_cv_type_uid_t" >&6; } +if test $ac_cv_type_uid_t = no; then + +$as_echo "#define uid_t int" >>confdefs.h + + +$as_echo "#define gid_t int" >>confdefs.h + +fi + + +ac_fn_c_check_member "$LINENO" "struct tm" "tm_gmtoff" "ac_cv_member_struct_tm_tm_gmtoff" "$ac_includes_default" +if test "x$ac_cv_member_struct_tm_tm_gmtoff" = xyes; then : + +cat >>confdefs.h <<_ACEOF +#define HAVE_STRUCT_TM_TM_GMTOFF 1 +_ACEOF + + +fi + + +# Look for some functions +for ac_func in getpagesize kqueue statfs statvfs \ + clone kse_create rfork_thread thr_create sa_register \ + getcontext makecontext setcontext sigaltstack swapcontext +do : + as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` +ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" +if eval test \"x\$"$as_ac_var"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + +fi +done + + + + + + for ac_header in $ac_header_list +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + + + + + + + +for ac_func in getpagesize +do : + ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" +if test "x$ac_cv_func_getpagesize" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_GETPAGESIZE 1 +_ACEOF + +fi +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 +$as_echo_n "checking for working mmap... " >&6; } +if ${ac_cv_func_mmap_fixed_mapped+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + ac_cv_func_mmap_fixed_mapped=no +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_includes_default +/* malloc might have been renamed as rpl_malloc. */ +#undef malloc + +/* Thanks to Mike Haertel and Jim Avera for this test. + Here is a matrix of mmap possibilities: + mmap private not fixed + mmap private fixed at somewhere currently unmapped + mmap private fixed at somewhere already mapped + mmap shared not fixed + mmap shared fixed at somewhere currently unmapped + mmap shared fixed at somewhere already mapped + For private mappings, we should verify that changes cannot be read() + back from the file, nor mmap's back from the file at a different + address. (There have been systems where private was not correctly + implemented like the infamous i386 svr4.0, and systems where the + VM page cache was not coherent with the file system buffer cache + like early versions of FreeBSD and possibly contemporary NetBSD.) + For shared mappings, we should conversely verify that changes get + propagated back to all the places they're supposed to be. + + Grep wants private fixed already mapped. + The main things grep needs to know about mmap are: + * does it exist and is it safe to write into the mmap'd area + * how to use it (BSD variants) */ + +#include +#include + +#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H +char *malloc (); +#endif + +/* This mess was copied from the GNU getpagesize.h. */ +#ifndef HAVE_GETPAGESIZE +# ifdef _SC_PAGESIZE +# define getpagesize() sysconf(_SC_PAGESIZE) +# else /* no _SC_PAGESIZE */ +# ifdef HAVE_SYS_PARAM_H +# include +# ifdef EXEC_PAGESIZE +# define getpagesize() EXEC_PAGESIZE +# else /* no EXEC_PAGESIZE */ +# ifdef NBPG +# define getpagesize() NBPG * CLSIZE +# ifndef CLSIZE +# define CLSIZE 1 +# endif /* no CLSIZE */ +# else /* no NBPG */ +# ifdef NBPC +# define getpagesize() NBPC +# else /* no NBPC */ +# ifdef PAGESIZE +# define getpagesize() PAGESIZE +# endif /* PAGESIZE */ +# endif /* no NBPC */ +# endif /* no NBPG */ +# endif /* no EXEC_PAGESIZE */ +# else /* no HAVE_SYS_PARAM_H */ +# define getpagesize() 8192 /* punt totally */ +# endif /* no HAVE_SYS_PARAM_H */ +# endif /* no _SC_PAGESIZE */ + +#endif /* no HAVE_GETPAGESIZE */ + +int +main () +{ + char *data, *data2, *data3; + const char *cdata2; + int i, pagesize; + int fd, fd2; + + pagesize = getpagesize (); + + /* First, make a file with some known garbage in it. */ + data = (char *) malloc (pagesize); + if (!data) + return 1; + for (i = 0; i < pagesize; ++i) + *(data + i) = rand (); + umask (0); + fd = creat ("conftest.mmap", 0600); + if (fd < 0) + return 2; + if (write (fd, data, pagesize) != pagesize) + return 3; + close (fd); + + /* Next, check that the tail of a page is zero-filled. File must have + non-zero length, otherwise we risk SIGBUS for entire page. */ + fd2 = open ("conftest.txt", O_RDWR | O_CREAT | O_TRUNC, 0600); + if (fd2 < 0) + return 4; + cdata2 = ""; + if (write (fd2, cdata2, 1) != 1) + return 5; + data2 = (char *) mmap (0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0L); + if (data2 == MAP_FAILED) + return 6; + for (i = 0; i < pagesize; ++i) + if (*(data2 + i)) + return 7; + close (fd2); + if (munmap (data2, pagesize)) + return 8; + + /* Next, try to mmap the file at a fixed address which already has + something else allocated at it. If we can, also make sure that + we see the same garbage. */ + fd = open ("conftest.mmap", O_RDWR); + if (fd < 0) + return 9; + if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_FIXED, fd, 0L)) + return 10; + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data2 + i)) + return 11; + + /* Finally, make sure that changes to the mapped area do not + percolate back to the file as seen by read(). (This is a bug on + some variants of i386 svr4.0.) */ + for (i = 0; i < pagesize; ++i) + *(data2 + i) = *(data2 + i) + 1; + data3 = (char *) malloc (pagesize); + if (!data3) + return 12; + if (read (fd, data3, pagesize) != pagesize) + return 13; + for (i = 0; i < pagesize; ++i) + if (*(data + i) != *(data3 + i)) + return 14; + close (fd); + free (data); + free (data3); + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + ac_cv_func_mmap_fixed_mapped=yes +else + ac_cv_func_mmap_fixed_mapped=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 +$as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } +if test $ac_cv_func_mmap_fixed_mapped = yes; then + +$as_echo "#define HAVE_MMAP 1" >>confdefs.h + +fi +rm -f conftest.mmap conftest.txt + + +# +# Disable common symbols +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-common" >&5 +$as_echo_n "checking whether ${CC_BASE} accepts -fno-common... " >&6; } +save_cflags="$CFLAGS" +CFLAGS="$CFLAGS -fno-common" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + use_no_common="yes" +else + use_no_common="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_common" >&5 +$as_echo "$use_no_common" >&6; } +if test "x-$use_no_common" = "x-yes" ; then + aros_host_cflags="$aros_host_cflags -fno-common" +fi +CFLAGS="$save_cflags" + + +#----------------------------------------------------------------------------- + +# +# GCC 4.1+ has a stack protection feature that requires OS support. Ubuntu has +# it switched on by default, and we use the host compiler, so it compiles AROS +# code with this enabled resulting in link failures as we don't have support +# for it. +# +# We use two methods to disable it. For the host compiler (used to compile +# some hosted modules), we test to see if the compiler supports stack +# protection, and if it does we disable it in AROS_CONFIG_CFLAGS. This should +# work on all platforms. +# + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-stack-protector" >&5 +$as_echo_n "checking whether ${CC_BASE} accepts -fno-stack-protector... " >&6; } +save_cflags="$CFLAGS" +CFLAGS="$CFLAGS -fno-stack-protector" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + use_no_stack_protector="yes" +else + use_no_stack_protector="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +$as_echo "$use_no_stack_protector" >&6; } +if test "x-$use_no_stack_protector" = "x-yes" ; then + aros_host_cflags="$aros_host_cflags -fno-stack-protector" +fi +CFLAGS="$save_cflags" + +#----------------------------------------------------------------------------- + +# Disable pointer-signedness warnings if the compiler recognises the option +# (this only works for the host compiler at the moment) + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -Wno-pointer-sign" >&5 +$as_echo_n "checking whether ${CC_BASE} accepts -Wno-pointer-sign... " >&6; } +save_cflags="$CFLAGS" +CFLAGS="$CFLAGS -Wno-pointer-sign" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + use_no_sign_warning="yes" +else + use_no_sign_warning="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_sign_warning" >&5 +$as_echo "$use_no_sign_warning" >&6; } +if test "x-$use_no_sign_warning" = "x-yes" ; then + aros_host_cflags="$aros_host_cflags -Wno-pointer-sign" +fi +CFLAGS="$save_cflags" + +#----------------------------------------------------------------------------- + +# Check if host compiler supports -fgnu89-inline, can be needed for crosstools. + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fgnu89-inline" >&5 +$as_echo_n "checking whether ${CC_BASE} accepts -fgnu89-inline... " >&6; } +save_cflags="$CFLAGS" +CFLAGS="$CFLAGS -fgnu89-inline" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + use_gnu89_inline="yes" +else + use_gnu89_inline="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_gnu89_inline" >&5 +$as_echo "$use_gnu89_inline" >&6; } +if test "x-$use_gnu89_inline" = "x-yes" ; then + gnu89_inline="-fgnu89-inline" +fi +CFLAGS="$save_cflags" + +# +# For GCC < 4.0 -I- is used for giving the search path for '#include "..."' +# On GCC >= 4.0 -iquote should be used +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -iquote" >&5 +$as_echo_n "checking whether ${CC_BASE} accepts -iquote... " >&6; } +CFLAGS="$CFLAGS -iquote." +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + has_iquote="yes" +else + has_iquote="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +$as_echo "$has_iquote" >&6; } +if test "x-$has_iquote" = "x-yes" ; then + host_cflags_iquote=-iquote + host_cflags_iquote_end= +else + host_cflags_iquote=-I + host_cflags_iquote_end=-I- +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: Performing target configuration..." >&5 +$as_echo "$as_me: Performing target configuration..." >&6;} + + +test_kernel_cc=no + +aros_nowarn_flags="NOWARN_UNUSED_COMMAND_LINE_ARGUMENT NOWARN_UNKNOWN_WARNING_OPTION NOWARN_POINTER_SIGN NOWARN_PARENTHESES" +export_newline=" +" + +aros_elf_translate= +aros_warn_flags= +aros_isa_extra= +aros_isa_flags= +aros_kernel_isa_flags= +aros_config_cppflags= +aros_config_cflags= +aros_config_cxxflags= +aros_config_aflags="$""(WARN_ALL) -x assembler-with-cpp -c" +aros_config_ldflags="" + +aros_shared_default=yes + +aros_shared_cflags="-fPIC" +aros_shared_aflags="" +aros_shared_ldflags="-Wl,-rpath,./lib -shared" +aros_kernel_ldflags="-Wl,-rpath,./lib" + +aros_kernel_ar_flags="cr" +aros_target_ar_flags="cr" +aros_target_nm_flags="--demangle --undefined-only" +aros_target_strip_flags="--strip-unneeded -R.comment" + +aros_c_libs= +aros_cxx_libs= + +aros_target_genmap="-Wl,-Map -Xlinker" + +# Native flavour stuff +aros_serial_debug="0" + +# Palm native flavour stuff +aros_palm_debug_hack="0" + +# Unix flavour stuff +aros_nesting_supervisor="0" + +# Collect-aros stuff: "-ius" to ignore undefined symbols +ignore_undefined_symbols="" + +# Check for X11 by default +need_x11="auto" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Which toolchain family to use ..." >&5 +$as_echo_n "checking Which toolchain family to use ...... " >&6; } + +# Check whether --with-toolchain was given. +if test "${with_toolchain+set}" = set; then : + withval=$with_toolchain; aros_toolchain="$withval" +else + aros_toolchain="$default_toolchain_family" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_toolchain" >&5 +$as_echo "$aros_toolchain" >&6; } + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable link time optimizations (LTO)" >&5 +$as_echo_n "checking if we should enable link time optimizations (LTO)... " >&6; } +# Check whether --enable-lto was given. +if test "${enable_lto+set}" = set; then : + enableval=$enable_lto; aros_config_lto="$enableval" +else + aros_config_lto="no" +fi + +if test "$aros_config_lto" != "no"; then + aros_config_lto="yes" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_lto" >&5 +$as_echo "$aros_config_lto" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable coverage instrumentation" >&5 +$as_echo_n "checking if we should enable coverage instrumentation... " >&6; } +# Check whether --enable-coverage was given. +if test "${enable_coverage+set}" = set; then : + enableval=$enable_coverage; aros_config_coverage="$enableval" +else + aros_config_coverage="no" +fi + +if test "$aros_config_coverage" != "no"; then + aros_config_coverage="yes" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_coverage" >&5 +$as_echo "$aros_config_coverage" >&6; } + +use_ld_wrapper=yes + +case "$aros_toolchain" in + *llvm*) + toolchain_c_compiler="clang" + toolchain_cxx_compiler="clang++" + toolchain_cpp_preprocessor="clang" + toolchain_cpp_opts=" -E" + toolchain_ld="ld.lld" + aros_ld="ld" + toolchain_as="llvm-as" + toolchain_ar="llvm-ar" + toolchain_ranlib="llvm-ranlib" + toolchain_nm="llvm-nm" + toolchain_strip="${NOP}" + toolchain_objcopy="llvm-objcopy" + toolchain_objdump="llvm-objdump" + use_libatomic=yes + toolchain_def_opt_lvl="-O2" + toolchain_debug_opt_lvl="-O0" + toolchain_size_opt_lvl="-Os" + aros_cxx_ldflags="-L $""(CROSSTOOLSDIR)/lib -stdlib=libc++" + aros_nowarn_flags="$aros_nowarn_flags NOWARN_IGNORED_OPTIMIZATION_ARGUMENT" + ;; + *gnu*) + toolchain_c_compiler="gcc" + toolchain_cxx_compiler="g++" + toolchain_cpp_preprocessor="gcc" + toolchain_cpp_opts=" -E" + toolchain_as="as" + aros_ld="ld" + if test "$aros_config_lto" != "yes"; then + toolchain_ld="ld" + toolchain_ar="ar" + toolchain_ranlib="ranlib" + toolchain_nm="nm" + else + toolchain_ld="ld.bfd" + toolchain_ar="gcc-ar" + toolchain_ranlib="gcc-ranlib" + toolchain_nm="gcc-nm" + fi + aros_target_nm_flags="$aros_target_nm_flags --line-numbers" + toolchain_strip="strip" + toolchain_objcopy="objcopy" + toolchain_objdump="objdump" + use_libatomic=yes + toolchain_def_opt_lvl="-O2" + toolchain_debug_opt_lvl="-O0" + toolchain_size_opt_lvl="-Os" + aros_cxx_ldflags="-static-libstdc++" + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown toolchain family!\"" >&5 +$as_echo "$as_me: WARNING: \"Unknown toolchain family!\"" >&2;} + toolchain_c_compiler="cc" + toolchain_cxx_compiler="c++" + toolchain_cpp_preprocessor="cpp" + toolchain_cpp_opts= + toolchain_ld="ld" + aros_ld="ld" + toolchain_as="as" + toolchain_ar="ar" + toolchain_ranlib="ranlib" + toolchain_nm="nm" + toolchain_strip="strip" + toolchain_objcopy="objcopy" + toolchain_objdump="objdump" + ;; +esac + +#----------------------------------------------------------------------------- + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which type of build to do" >&5 +$as_echo_n "checking which type of build to do... " >&6; } +# Check whether --enable-build_type was given. +if test "${enable_build_type+set}" = set; then : + enableval=$enable_build_type; build_type=$enableval +else + build_type="personal" +fi + + +if test "$build_type" = "nightly"; then + build_type_string="NIGHTLY" +elif test "$build_type" = "snapshot"; then + build_type_string="SNAPSHOT" +elif test "$build_type" = "milestone"; then + build_type_string="MILESTONE" +elif test "$build_type" = "release"; then + build_type_string="RELEASE" +else + build_type_string="PERSONAL" + build_type="personal" +fi + +aros_config_cppflags="$aros_config_cppflags -DAROS_BUILD_TYPE=AROS_BUILD_TYPE_$build_type_string" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $build_type" >&5 +$as_echo "$build_type" >&6; } + +#----------------------------------------------------------------------------- +all_debug_types="messages stack modules mungwall symbols" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug types to enable" >&5 +$as_echo_n "checking which debug types to enable... " >&6; } +# Check whether --enable-debug was given. +if test "${enable_debug+set}" = set; then : + enableval=$enable_debug; debug="$enableval" +else + debug="" +fi + + +if test "$debug" = "" -o "$debug" = "no"; then + debug="none" +elif test "$debug" = "yes"; then + debug="all" +fi + +if test "$debug" = "all" ; then + debug="messages stack modules symbols" + for d in $all_debug_types; do + export aros_${d}_debug="1" + done +else + for d in $all_debug_types; do + export aros_${d}_debug="0" + done +fi + +if test "$debug" != "none"; then + debug=`echo $debug | sed s/,/\ /g` + for d in $debug; do + found="0" + for d2 in $all_debug_types; do + if test "$d2" = "$d"; then + found="1" + break + fi + done + if test "$found" = "0"; then + as_fn_error $? "unrecognized debug type \"$d\". Available types are: all none $all_debug_types" "$LINENO" 5 + fi + export aros_${d}_debug="1" + done + aros_debug="yes" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $debug" >&5 +$as_echo "$debug" >&6; } + +if test "$aros_messages_debug" = "1"; then + aros_messages_debug="-DADEBUG=1 -DMDEBUG=1" +else + aros_messages_debug="" +fi +if test "$aros_symbols_debug" = "1"; then + aros_symbols_debug="-g" +else + aros_symbols_debug="" +fi + +# These are the flags to pass when compiling debugged programs +aros_debug_cppflags="$aros_messages_debug" +aros_debug_cflags="$aros_symbols_debug" +aros_debug_cxxflags= +aros_debug_aflags="" +aros_debug_ldflags="$aros_symbols_debug" + +#----------------------------------------------------------------------------- +# Checking for distcc and ccache. +# +# Always apply the transforms in this particular order. Basically you should +# always run 'ccache distcc compiler' in that order for the best performance. +# +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable distcc" >&5 +$as_echo_n "checking whether to enable distcc... " >&6; } +# Check whether --enable-distcc was given. +if test "${enable_distcc+set}" = set; then : + enableval=$enable_distcc; distcc="$enableval" +else + distcc="no" +fi + +if test "$distcc" != "" -a "$distcc" != "no"; then + # AC_CHECK_PROG will print out the result in this case + # Extract the first word of "distcc", so it can be a program name with args. +set dummy distcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_DISTCC+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $DISTCC in + [\\/]* | ?:[\\/]*) + ac_cv_path_DISTCC="$DISTCC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_DISTCC="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_path_DISTCC" && ac_cv_path_DISTCC="distcc" + ;; +esac +fi +DISTCC=$ac_cv_path_DISTCC +if test -n "$DISTCC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DISTCC" >&5 +$as_echo "$DISTCC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable ccache" >&5 +$as_echo_n "checking whether to enable ccache... " >&6; } +# Check whether --enable-ccache was given. +if test "${enable_ccache+set}" = set; then : + enableval=$enable_ccache; ccache="$enableval" +else + ccache="no" +fi + +if test "$ccache" != "" -a "$ccache" != "no"; then + # AC_CHECK_PROG will print out the result in this case + # Extract the first word of "ccache", so it can be a program name with args. +set dummy ccache; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CCACHE+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CCACHE"; then + ac_cv_prog_CCACHE="$CCACHE" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_CCACHE="ccache" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CCACHE=$ac_cv_prog_CCACHE +if test -n "$CCACHE"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 +$as_echo "$CCACHE" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific host gcc version to use" >&5 +$as_echo_n "checking what specific host gcc version to use... " >&6; } + +# Check whether --with-kernel-gcc-version was given. +if test "${with_kernel_gcc_version+set}" = set; then : + withval=$with_kernel_gcc_version; kernel_tool_version="$withval" +else + kernel_tool_version="" +fi + +if test "$kernel_tool_version" != "" ; then + msg_result=$kernel_tool_version +else + msg_result="default" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +$as_echo "$msg_result" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what optimization flags to use" >&5 +$as_echo_n "checking what optimization flags to use... " >&6; } + +# Check whether --with-optimization was given. +if test "${with_optimization+set}" = set; then : + withval=$with_optimization; optimization_level="$withval" +else + optimization_level="unknown" +fi + +if test "$optimization_level" = "unknown"; then + optimization="default" + if test "$debug" != "none"; then + optimization_level=$toolchain_debug_opt_lvl + else + optimization_level=$toolchain_def_opt_lvl + fi +else + optimization="$optimization_level" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization" >&5 +$as_echo "$optimization" >&6; } + +paranoia_default=yes +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which paranoia flags to use" >&5 +$as_echo_n "checking which paranoia flags to use... " >&6; } + +# Check whether --with-paranoia was given. +if test "${with_paranoia+set}" = set; then : + withval=$with_paranoia; paranoia_flags="$withval" +else + paranoia_flags="$paranoia_default" +fi + +if test "$paranoia_flags" = "no"; then + paranoia_flags="$""(WARN_ALL) -Werror-implicit-function-declaration" + msg_result="none" +else + if test "$paranoia_flags" = "yes"; then + paranoia_flags="$""(WARN_ALL) $""(WARN_ERROR)" + fi + msg_result="$paranoia_flags" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +$as_echo "$msg_result" >&6; } +aros_warn_flags="$aros_warn_flags $paranoia_flags" + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what target variant to enable" >&5 +$as_echo_n "checking what target variant to enable... " >&6; } +# Check whether --enable-target_variant was given. +if test "${enable_target_variant+set}" = set; then : + enableval=$enable_target_variant; target_variant=$enableval +else + target_variant="" +fi + +if test "$target_variant" = ""; then + aros_target_variant="" + aros_target_suffix="" + enableval="none" +else + aros_target_variant="$target_variant" + aros_target_suffix="-$target_variant" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5 +$as_echo "$enableval" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro name to use" >&5 +$as_echo_n "checking what distro name to use... " >&6; } +# Check whether --enable-dist_name was given. +if test "${enable_dist_name+set}" = set; then : + enableval=$enable_dist_name; dist_name="$enableval" +else + dist_name="" +fi + +if test "$dist_name" = ""; then + aros_dist_name="$aros_dist_name" +else + aros_dist_name="$dist_name" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_name" >&5 +$as_echo "$aros_dist_name" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro version" >&5 +$as_echo_n "checking what distro version... " >&6; } +# Check whether --enable-dist_version was given. +if test "${enable_dist_version+set}" = set; then : + enableval=$enable_dist_version; dist_version="$enableval" +else + dist_version="" +fi + +if test "$dist_version" = ""; then + aros_dist_version="$aros_dist_version" +else + aros_dist_version="$dist_version" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_version" >&5 +$as_echo "$aros_dist_version" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro date" >&5 +$as_echo_n "checking what distro date... " >&6; } +# Check whether --enable-dist_date was given. +if test "${enable_dist_date+set}" = set; then : + enableval=$enable_dist_date; dist_date=$enableval +else + dist_date="" +fi + +if test "$dist_date" = ""; then + aros_dist_date="$aros_dist_date" +else + aros_dist_date="$dist_date" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_date" >&5 +$as_echo "$aros_dist_date" >&6; } + +#----------------------------------------------------------------------------- +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro amigadate" >&5 +$as_echo_n "checking what distro amigadate... " >&6; } +# Check whether --enable-dist_amigadate was given. +if test "${enable_dist_amigadate+set}" = set; then : + enableval=$enable_dist_amigadate; dist_amigadate=$enableval +else + dist_amigadate="" +fi + +if test "$dist_amigadate" = ""; then + aros_dist_amigadate="$aros_dist_amigadate" +else + aros_dist_amigadate="$dist_amigadate" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_amigadate" >&5 +$as_echo "$aros_dist_amigadate" >&6; } + + +#----------------------------------------------------------------------------- +# Target-specific defaults. You can override then on a per-target basis. +# +# Bootloader name. Currently used by PC target. +target_bootloader="none" +PLATFORM_EXECSMP= +ENABLE_EXECSMP= + +#----------------------------------------------------------------------------- +# Additional options for some specific targets + +case "$aros_target_variant" in +ios) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking XCode path" >&5 +$as_echo_n "checking XCode path... " >&6; } + +# Check whether --with-xcode was given. +if test "${with_xcode+set}" = set; then : + withval=$with_xcode; aros_xcode_path="$withval" +else + aros_xcode_path="/Developer" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_xcode_path" >&5 +$as_echo "$aros_xcode_path" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what iOS SDK version to use" >&5 +$as_echo_n "checking what iOS SDK version to use... " >&6; } + +# Check whether --with-sdk-version was given. +if test "${with_sdk_version+set}" = set; then : + withval=$with_sdk_version; aros_sdk_version="$withval" +else + aros_sdk_version="4.1" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +$as_echo "$aros_sdk_version" >&6; } + + ;; + +"android") + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android SDK path" >&5 +$as_echo_n "checking Android SDK path... " >&6; } + +# Check whether --with-sdk was given. +if test "${with_sdk+set}" = set; then : + withval=$with_sdk; aros_android_sdk="$withval" +else + aros_android_sdk=$default_android_sdk +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_sdk" >&5 +$as_echo "$aros_android_sdk" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android NDK path" >&5 +$as_echo_n "checking Android NDK path... " >&6; } + +# Check whether --with-ndk was given. +if test "${with_ndk+set}" = set; then : + withval=$with_ndk; aros_android_ndk="$withval" +else + aros_android_ndk="none" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_ndk" >&5 +$as_echo "$aros_android_ndk" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android SDK version to use" >&5 +$as_echo_n "checking what Android SDK version to use... " >&6; } + +# Check whether --with-sdk-version was given. +if test "${with_sdk_version+set}" = set; then : + withval=$with_sdk_version; aros_sdk_version="$withval" +else + aros_sdk_version="12" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +$as_echo "$aros_sdk_version" >&6; } + + aros_android_level=android-$aros_sdk_version + if test ! -d $aros_android_sdk/platforms/$aros_android_level; then + echo "Platform $aros_android_level is not installed in your SDK" + echo "Use --with-sdk-version= to select another platform version" + echo "You can check what plaform versions are installed in your SDK" + echo "by examining contents of $aros_android_sdk/platforms directory" + as_fn_error $? "Android platform $aros_android_level is not installed" "$LINENO" 5 + fi + + export PATH="$aros_android_sdk/tools:$PATH" + # Extract the first word of "$android_tool", so it can be a program name with args. +set dummy $android_tool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_android_tool+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $android_tool in + [\\/]* | ?:[\\/]*) + ac_cv_path_android_tool="$android_tool" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_android_tool="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +android_tool=$ac_cv_path_android_tool +if test -n "$android_tool"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $android_tool" >&5 +$as_echo "$android_tool" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + req_avail=yes +if test "$android_tool" = ""; then + req_avail=no +fi +if test "$android_tool" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "android is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + if test "$aros_android_ndk" != "none"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android NDK version to use" >&5 +$as_echo_n "checking what Android NDK version to use... " >&6; } + +# Check whether --with-ndk-version was given. +if test "${with_ndk_version+set}" = set; then : + withval=$with_ndk_version; aros_ndk_version="$withval" +else + aros_ndk_version="9" +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_ndk_version" >&5 +$as_echo "$aros_ndk_version" >&6; } + fi + + # Extract the first word of "ant", so it can be a program name with args. +set dummy ant; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_ant+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $ant in + [\\/]* | ?:[\\/]*) + ac_cv_path_ant="$ant" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_ant="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +ant=$ac_cv_path_ant +if test -n "$ant"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ant" >&5 +$as_echo "$ant" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test "$ant" = ""; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&5 +$as_echo "$as_me: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&2;} + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Build debug or release apk" >&5 +$as_echo_n "checking Build debug or release apk... " >&6; } + +# Check whether --with-apk-version was given. +if test "${with_apk_version+set}" = set; then : + withval=$with_apk_version; aros_android_antapk=$withval +else + aros_android_antapk=release +fi + + if test $aros_android_antapk != release -a $aros_android_antapk != debug; then + as_fn_error $? "apk-version has to be release or debug" "$LINENO" 5 + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_antapk" >&5 +$as_echo "$aros_android_antapk" >&6; } + + target_extra_cfg+="$export_newline""# Android$export_newline""AROS_ANDROID_ANTAPK := $aros_android_antapk$export_newline" + host_extra_cfg+="$export_newline""# Android-specific$export_newline""ANDROID := $android_tool$export_newline""ANT := $ant$export_newline" + aros_target_options+="$export_newline""# Enable Android Gfx Driver$export_newline""OPT_HOST_ANDROIDGFX := yes$export_newline" + + if test "$host_os" = "mingw32"; then + android_tool="cmd //c $android_tool" + fi + + need_dlopen="no" + + ;; +"be") + case "$target_cpu" in + *arm*) + aros_flavour="standcompat" + aros_object_format="armelfb_aros" + gcc_default_endian="big-endian" + ;; + *) + ;; + esac + ;; +esac + +#----------------------------------------------------------------------------- +# External toolchains +kernel_tool_prefix="none" +aros_tool_prefix="none" +elf_tool_prefix="${target_cpu}-elf-" + +# Base target cpu ISA configuration switch. +case "$target_cpu" in + *aarch64*) + ;; + *armhf*) + if test "$gcc_default_endian" = ""; then + gcc_default_endian="little-endian" + fi + arm_isa_extra="ISA_ARM_FLAGS = -marm -mfloat-abi=hard -m"$gcc_default_endian + ;; + *arm*) + if test "$gcc_default_endian" = ""; then + gcc_default_endian="little-endian" + fi + arm_isa_extra="ISA_ARM_FLAGS = -marm"$gcc_default_endian + ;; + *m68k*) + m68k_isa_extra="ISA_FLOAT_FLAGS = -msoft-float""$export_newline""ISA_MC68000_FLAGS = -march=68000 $""(ISA_FLOAT_FLAGS)" + m68k_020_isa_extra="ISA_MC68020_FLAGS = -march=68020 $""(ISA_FLOAT_FLAGS)" + m68k_030_isa_extra="ISA_MC68030_FLAGS = -march=68030 $""(ISA_FLOAT_FLAGS)" + m68k_040_isa_extra="ISA_MC68040_FLAGS = -march=68040 $""(ISA_FLOAT_FLAGS)" + m68k_060_isa_extra="ISA_MC68060_FLAGS = -march=68060 $""(ISA_FLOAT_FLAGS)" + m68k_ac080_isa_extra="ISA_AC68080_FLAGS = -march=68040 $""(ISA_FLOAT_FLAGS)" + m68k_020_ext="ISA_MC68020_EXT :=020" + m68k_030_ext="ISA_MC68030_EXT :=030" + m68k_040_ext="ISA_MC68040_EXT :=040" + m68k_060_ext="ISA_MC68060_EXT :=060" + m68k_020_cflags="ISA_MC68020_CFLAGS =" + m68k_030_cflags="ISA_MC68030_CFLAGS =" + m68k_040_cflags="ISA_MC68040_CFLAGS =" + m68k_060_cflags="ISA_MC68060_CFLAGS =" + m68k_020_cppflags="ISA_MC68020_CPPFLAGS =" + m68k_030_cppflags="ISA_MC68030_CPPFLAGS =" + m68k_040_cppflags="ISA_MC68040_CPPFLAGS =" + m68k_060_cppflags="ISA_MC68060_CPPFLAGS =" + m68k_020_ldflags="ISA_MC68020_LDFLAGS =" + m68k_030_ldflags="ISA_MC68030_LDFLAGS =" + m68k_040_ldflags="ISA_MC68040_LDFLAGS =" + m68k_060_ldflags="ISA_MC68060_LDFLAGS =" + ;; + *x86_64* | *i?86*) + x86_isa_extra="ISA_X86_FLAGS = -m32 -march=i486" + x86_64_isa_extra="ISA_X8664_FLAGS = -m64 -mcmodel=large" + ;; + *powerpc*) + ;; +esac + +# This is the target configuration switch. +case "$target_os" in + linux*) + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="linux" + aros_target_family="unix" + case "$target_cpu" in + *m68k*) + aros_target_cpu="m68k" + aros_object_format="m68kelf" + aros_flavour="emulcompat" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -D__mc68000 -D__linux__" + aros_isa_flags="$""(ISA_MC68000_FLAGS)" + aros_shared_ldflags="-Wl,-T,\$(TOP)/config/linux/m68k/script.so" + aros_kernel_ldflags="-Wl,-rpath,./lib,-T,\$(TOP)/config/linux/m68k/script.normal" + gcc_target_cpu="mc68000" + ;; + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386 -D__linux__" + aros_isa_flags="$""(ISA_X86_FLAGS)" + aros_kernel_isa_flags="$""(ISA_X86_FLAGS)" + x86_64_isa_extra="$x86_64_isa_extra $""(CFLAGS_NO_RED_ZONE)" + aros_kernel_ldflags="-Wl,-melf_i386" + aros_nominal_depth=8 + gcc_target_cpu="i386" + pci_hidd_target="hidd-pci-linux" + android_tool_dir_prefix="x86" + android_tool_prefix="i686-android-linux" + android_ndk_arch="x86" + ;; + *x86_64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="x86_64" + aros_object_format="elf_x86_64" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dx86_64 -D__linux__" + aros_isa_flags="$""(ISA_X8664_FLAGS)" + aros_kernel_isa_flags="-m64" + x86_64_isa_extra="$x86_64_isa_extra $""(CFLAGS_NO_RED_ZONE)" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_OMIT_FP)" + aros_nominal_depth=8 + pci_hidd_target="hidd-pci-linux" + ;; + *powerpc*) + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc -D__linux__" + aros_nominal_depth=8 + gcc_target_cpu="ppc" + ;; +# TODO +# Same as powerpc, but I need this for the nightly build to work again. +# Actually, the nightly should be made working with powerpc target. +# That just was too much work for the moment, another week or two. + *ppc*) + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc -D__linux__" + aros_nominal_depth=8 + gcc_target_cpu="ppc" + ;; + *aarch64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="aarch64" + target_cpu="aarch64" + aros_object_format="aarch64elf_aros" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm -D__linux__" + gcc_target_cpu="aarch64" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_STRICT_ALIASING)" + aros_c_libs="$aros_c_libs -laeabi" + gcc_default_float_abi="hard" + kernel_tool_prefix="aarch64-linux-gnueabihf-" + ;; + *armhf*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="arm" + target_cpu="arm" + aros_object_format="armelf_aros" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm -D__linux__" + gcc_target_cpu="arm" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_STRICT_ALIASING)" + aros_c_libs="$aros_c_libs -laeabi" + gcc_default_float_abi="hard" + android_tool_dir_prefix="arm-linux-androideabi" + android_tool_prefix="arm-linux-androideabi" + android_ndk_arch="arm" + kernel_tool_prefix="arm-linux-gnueabihf-" + ;; + *arm*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="arm" + aros_object_format="armelf_aros" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm -D__linux__" + gcc_target_cpu="arm" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_OMIT_FP)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_STRICT_ALIASING)" + aros_c_libs="$aros_c_libs -laeabi" + android_tool_dir_prefix="arm-linux-androideabi" + android_tool_prefix="arm-linux-androideabi" + android_ndk_arch="arm" + kernel_tool_prefix="arm-linux-gnueabi-" + ;; + *) + as_fn_error $? "\"Unknown CPU for Linux -- $target_cpu\"" "$LINENO" 5 + ;; + esac + case "$aros_target_variant" in + android) + + if test "$android_ndk_arch" = ""; then + as_fn_error $? "\"Unsupported CPU for Android -- $target_cpu\"" "$LINENO" 5 + fi + + aros_nominal_width=320 + aros_nominal_height=480 + if test "$aros_android_ndk" = "none"; then + aros_kernel_cflags="-mandroid" + aros_kernel_ldflags="-mandroid" + CFLAGS="-mandroid" + else + export PATH="$aros_android_ndk/toolchains/$android_tool_dir_prefix-$kernel_tool_version/prebuilt/$android_build_os/bin:$PATH" + kernel_tool_version="" + aros_android_ndk="$aros_android_ndk/platforms/android-$aros_ndk_version/arch-$android_ndk_arch" + aros_kernel_cflags="--sysroot $aros_android_ndk -mandroid" + aros_kernel_ldflags="--sysroot $aros_android_ndk -mandroid" + CFLAGS="$CFLAGS --sysroot $aros_android_ndk -mandroid" + aros_kernel_includes="-isystem $aros_android_ndk/usr/include" + fi + need_x11=no + # Disable implicit PIC mode + aros_config_cflags="$aros_config_cflags -fno-pic" + kernel_tool_prefix="$android_tool_prefix-" + ;; + esac + ;; + + pc) + aros_target_arch="pc" + aros_shared_default="no" + target_bootloader="grub2" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + + + if test "$aros_object_format" = "" ; then + aros_object_format="elf_i386" + fi + aros_flavour="standalone" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386" + aros_isa_flags="$""(ISA_X86_FLAGS)" + x86_64_isa_extra="$x86_64_isa_extra $""(CFLAGS_NO_RED_ZONE)" + aros_kernel_ldflags="-Wl,-melf_i386" + aros_nominal_width=640 + aros_nominal_height=480 + gcc_target_cpu="i386" + ;; + *x86_64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="x86_64" + aros_serial_debug=1 + if test "$aros_object_format" = "" ; then + aros_object_format="elf_x86_64" + fi + aros_flavour="standalone" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dx86_64" + aros_isa_flags="$""(ISA_X8664_FLAGS)" + x86_64_isa_extra="$x86_64_isa_extra $""(CFLAGS_NO_RED_ZONE)" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_OMIT_FP)" + aros_kernel_ldflags="" + aros_nominal_width=640 + aros_nominal_height=480 + case "$aros_target_variant" in + smp) + ENABLE_EXECSMP="#define __AROSEXEC_SMP__" + ;; + esac + ;; + *) + as_fn_error $? "\"Unknown native CPU -- $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + prep) + aros_target_arch="prep" + aros_shared_default="no" + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_flavour="ppcnative" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc" + aros_kernel_ldflags="" + aros_nominal_width=640 + aros_nominal_height=480 + gcc_target_cpu="ppc" + ;; + + freebsd*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="freebsd" + aros_target_family="unix" + aros_target_cpu="i386" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386" + gcc_target_cpu="i386" + + aros_target_strip_flags="-x" + ;; + + darwin*) + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="darwin" + aros_target_family="unix" + aros_flavour="emulation" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_ios_platform="iPhoneSimulator" + aros_target_cpu="i386" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386" + aros_isa_flags="$""(ISA_X86_FLAGS)" + aros_kernel_isa_flags="-m32" + aros_kernel_ldflags="" + aros_macosx_version="10.4" + aros_nominal_depth=8 + gcc_target_cpu="i386" + aros_object_format="elf_i386" + aros_kernel_ar_flags="-cr" + aros_target_strip_flags="-x" + kernel_tool_flags="-m32" + ;; + *x86_64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="x86_64" + aros_object_format="elf_x86_64" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dx86_64" + aros_isa_flags="$""(ISA_X8664_FLAGS)" + aros_macosx_version="10.6" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_OMIT_FP)" + aros_kernel_isa_flags="-m64" + aros_kernel_ldflags="-m64" + aros_nominal_depth=8 + aros_kernel_rs="$toolchain_ar" + aros_kernel_ar_flags="-cr" + aros_kernel_ld="$toolchain_ld" + aros_kernel_as="$toolchain_as" + aros_kernel_ranlib="$toolchain_ranlib" + aros_kernel_nm="$toolchain_nm" + aros_kernel_strip="strip" + kernel_tool_prefix="i686-apple-darwin10-" + ;; + *ppc*) + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc" + aros_kernel_ldflags="" + aros_macosx_version="10.0" + aros_nominal_depth=8 + gcc_target_cpu="ppc" + aros_kernel_rs="$toolchain_ar" + aros_kernel_ar_flags="-cr" + aros_kernel_ld="$toolchain_ld -arch ppc" + aros_kernel_as="$toolchain_as -arch ppc" + aros_kernel_ranlib="$toolchain_ranlib -arch ppc" + aros_kernel_nm="$toolchain_nm -arch ppc" + aros_kernel_strip="strip -arch ppc" + kernel_tool_prefix="powerpc-apple-darwin10-" + ;; + *arm*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_ios_platform="iPhoneOS" + aros_target_cpu="arm" + aros_object_format="armelf_aros" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm" + aros_c_libs="$aros_c_libs -laeabi" + aros_nominal_depth=8 + gcc_target_cpu="arm" + aros_kernel_rs="$toolchain_ar" + aros_kernel_ar_flags="-cr" + aros_kernel_ld="$toolchain_ld -arch arm" + aros_kernel_ranlib="$toolchain_ranlib -arch arm" + kernel_tool_prefix="arm-apple-darwin10-" + export PATH="$aros_xcode_path/Platforms/$aros_ios_platform.platform/Developer/usr/bin:$PATH" + ;; + *) + as_fn_error $? "\"Unsupported target CPU for darwin hosted flavour -- $target_cpu\"" "$LINENO" 5 + ;; + esac + case "$aros_target_variant" in + ios) + make_extra_targetcfg="$export_newline""# Apple iOS stuff for gcc$export_newline""IOS_LDFLAGS := -F$""(IOS_SDK_PATH)/System/Library/Frameworks$export_newline" + aros_ios_version="3.0" + aros_nominal_width=320 + aros_nominal_height=480 + aros_ios_sdk="$aros_xcode_path/Platforms/$aros_ios_platform.platform/Developer/SDKs/$aros_ios_platform$aros_sdk_version.sdk" + target_extra_cfg+="$export_newline""# Apple iOS specific$export_newline""IOS_PLATFORM := $aros_ios_platform$export_newline""IOS_OS_VERSION := $aros_ios_version$export_newline""IOS_SDK_PATH := $aros_ios_sdk$export_newline" + kernel_tool_flags="$target_tool_flags -isysroot $aros_ios_sdk" + aros_kernel_includes="-isystem $aros_ios_sdk/usr/include" + need_x11=no + # This is here because it may depend on iOS or SDK version + aros_kernel_cflags="$aros_kernel_cflags -miphoneos-version-min=$aros_ios_version" + aros_kernel_ldflags="$aros_kernel_ldflags -miphoneos-version-min=$aros_ios_version" + aros_kernel_objcflags="-fobjc-abi-version=2 -fobjc-legacy-dispatch" + ;; + *) + aros_kernel_cflags="$aros_kernel_cflags -mmacosx-version-min=$aros_macosx_version" + aros_kernel_ldflags="$aros_kernel_ldflags -mmacosx-version-min=$aros_macosx_version" + ;; + esac + ;; + + dragonfly*) + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="dragonfly" + aros_target_family="unix" + aros_flavour="emulation" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386 -D__DragonFly__" + aros_isa_flags="$""(ISA_X86_FLAGS)" + ;; + *x86_64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_OMIT_FP)" + aros_target_cpu="x86_64" + aros_object_format="elf_x86_64" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dx86_64 -D__DragonFly__" + aros_isa_flags="$""(ISA_X8664_FLAGS)" + ;; + *) + as_fn_error $? "\"Unknown CPU for DragonFly -- $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + netbsd*) + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="netbsd" + aros_target_family="unix" + case "$target_cpu" in + *m68k*) + aros_target_cpu="m68k" + aros_object_format="m68kelf" + aros_flavour="emulcompat" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -D__mc68000 -D__NetBSD__" + aros_isa_flags="$""(ISA_MC68000_FLAGS)" + gcc_target_cpu="mc68000" + ;; + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386 -D__NetBSD__" + aros_isa_flags="$""(ISA_X86_FLAGS)" + aros_nominal_depth=8 + gcc_target_cpu="i386" + ;; + *) + as_fn_error $? "\"Unknown CPU for NetBSD -- $target_cpu\"" "$LINENO" 5 + ;; + esac + aros_target_genmap="-Wl,-M -Xlinker >" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386" + ;; + + openbsd*) + HOST_WANTS_X11=yes + HOST_WANTS_GLX=yes + HOST_WANTS_SDL=yes + HOST_WANTS_DBUS=yes + HOST_WANTS_DLOPEN=yes + aros_target_arch="openbsd" + aros_target_family="unix" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386 -D__OpenBSD__" + aros_isa_flags="$""(ISA_X86_FLAGS)" + gcc_target_cpu="i386" + ;; + *) + as_fn_error $? "\"Unknown CPU for OpenBSD -- $target_cpu\"" "$LINENO" 5 + ;; + esac + aros_target_genmap="-Wl,-M -Xlinker >" + aros_target_nm_flags="-u" + aros_flavour="emulation" + ;; + + solaris*) + aros_target_arch="solaris" + aros_target_family="unix" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_flavour="emulation" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386 -D__Solaris__" + aros_isa_flags="$""(ISA_X86_FLAGS)" + aros_nominal_depth=8 + gcc_target_cpu="i386" + ;; + *sparc*) + aros_target_cpu="sparc" + aros_object_format="elf_sparc" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dsparc -D__Solaris__" + gcc_target_cpu="sparc" + ;; + *) + as_fn_error $? "\"Unknown CPU for Solaris -- $target_cpu\"" "$LINENO" 5 + ;; + esac + aros_config_cppflags="$aros_config_cppflags -D$aros_target_cpu" + aros_flavour="emulation" + ;; + + morphos*) + aros_target_arch="morphos" + aros_shared_default="no" + aros_target_cpu="ppc" + aros_object_format="elf_ppc" + aros_flavour="nativecompat" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc" + gcc_target_cpu="ppc" + ;; + + sam440) + aros_target_arch="sam440" + aros_shared_default="no" + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_flavour="ppcnative" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc" + aros_kernel_ldflags="" + aros_nominal_width=1024 + aros_nominal_height=768 + aros_nominal_depth=24 + aros_isa_flags="$aros_isa_flags -mcpu=440fp -mno-toc" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + gcc_target_cpu="powerpc" + ;; + + efika) + aros_target_arch="efika" + aros_shared_default="no" + aros_target_cpu="arm" + aros_object_format="armelf_aros" + aros_flavour="standalone" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm" + aros_kernel_ldflags="" + aros_nominal_width=1024 + aros_nominal_height=600 + aros_c_libs="$aros_c_libs -laeabi" + gcc_default_cpu="armv7-a" + gcc_default_fpu="vfpv3" + aros_isa_flags="$aros_isa_flags -mtune=cortex-a8" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + if test "$optimization" = "default"; then + optimization_level=$toolchain_size_opt_lvl + fi + case "$target_cpu" in + *armhf*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + gcc_default_float_abi="hard" + target_cpu=arm + aros_target_cpu=arm + ;; + *arm*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + gcc_default_float_abi="softfp" + ;; + *) + as_fn_error $? "\"Unknown CPU for EfikaMX $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + chrp) + aros_target_arch="chrp" + aros_shared_default="no" + aros_target_cpu="ppc" + aros_object_format="elf32ppc" + aros_flavour="ppcnative" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dppc" + aros_kernel_ldflags="" + aros_nominal_width=640 + aros_nominal_height=480 + aros_isa_flags="$aros_isa_flags -mno-toc" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES)" + gcc_target_cpu="powerpc" + case "$aros_target_variant" in + efika) + aros_isa_flags="$aros_isa_flags -mcpu=603e" + aros_config_cppflags="$aros_config_cppflags -DBIG_ENDIAN_OHCI=1" + ;; + esac + ;; + + r*pi) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_flavour="standalone" + aros_target_arch="raspi" + + aros_shared_default="no" + + aros_target_mkdep="$aros_target_mkdep -D__GNUC__" + + case "$target_cpu" in + *aarch64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="aarch64" + gcc_default_cpu="armv8-a+crc" + gcc_default_cpu_tune="cortex-a53" + gcc_default_fpu="neon-fp-armv8" + aros_object_format="aarch64elf_aros" + ;; + *armhf*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="arm" + gcc_default_cpu="armv7-a+fp" + if test "$aros_object_format" = "" ; then + aros_object_format="armelf_aros" + fi + aros_isa_flags="$""(ISA_ARM_FLAGS)" + aros_config_cflags="$aros_config_cflags" + aros_config_cxxflags="$aros_config_cxxflags" + aros_config_aflags="$aros_config_aflags" + aros_kernel_cflags="$aros_kernel_cflags" + aros_target_mkdep="$aros_target_mkdep -Darm" + aros_c_libs="$aros_c_libs -laeabi" + ;; + *arm*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="arm" + gcc_default_cpu="armv7-a" + if test "$aros_object_format" = "" ; then + aros_object_format="armelf_aros" + fi + aros_isa_flags="$""(ISA_ARM_FLAGS)" + aros_config_cflags="$aros_config_cflags" + aros_config_cxxflags="$aros_config_cxxflags" + aros_config_aflags="$aros_config_aflags" + aros_kernel_cflags="$aros_kernel_cflags" + aros_target_mkdep="$aros_target_mkdep -Darm" + aros_c_libs="$aros_c_libs -laeabi" + ;; + *) + as_fn_error $? "\"Unsupported CPU for RasPi $target_cpu\"" "$LINENO" 5 + ;; + esac + + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + aros_kernel_cflags="$aros_kernel_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + + case "$aros_target_variant" in + smp) + ENABLE_EXECSMP="#define __AROSEXEC_SMP__" + ;; + esac + ;; + + stm32f7_discovery) + aros_flavour="standalone" + aros_target_arch="stm32f7_discovery" + aros_target_cpu="arm" + aros_target_cpu_mode="thumb2" + aros_object_format="armelf_aros" + aros_shared_default="no" + + gcc_default_cpu="armv7e-m" + gcc_default_cpu_tune="cortex-m7" + gcc_default_fpu="fpv5-sp-d16" + gcc_default_float_abi="hard" + + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dthumb" + ;; + + amiga*) + aros_elf_translate="$""(ELF2HUNK)" + make_extra_commands="$export_newline""ELF2HUNK := $""(TOOLDIR)/elf2hunk$""(HOST_EXE_SUFFIX)$export_newline" + aros_target_arch="amiga" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -D_AMIGA -DAMIGA" + aros_shared_default="no" + + case "$target_cpu" in + *m68k*) + # Check whether --enable-amigaos_compliance was given. +if test "${enable_amigaos_compliance+set}" = set; then : + enableval=$enable_amigaos_compliance; aros_amigaos_compliance="$enableval" +fi + + aros_enable_mmu=no + aros_target_cpu="m68k" + aros_object_format="m68kelf" + aros_flavour="standcompat" + gcc_target_cpu="m68000" + aros_isa_flags="$""(ISA_MC"$aros_gcc_cpu"_FLAGS)" + aros_nowarn_flags="$aros_nowarn_flags NOWARN_VOLATILE_REGISTER_VAR" + aros_config_cppflags="$aros_config_cppflags -DNOLIBINLINE" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_FREESTANDING) $""(CFLAGS_OMIT_FP) $""(CFLAGS_BUILTIN)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_STRICT_ALIASING) $""(CFLAGS_FREESTANDING) $""(CFLAGS_OMIT_FP) $""(CFLAGS_BUILTIN)" + if test "$optimization" = "default"; then + optimization_level=$toolchain_size_opt_lvl + fi + aros_config_aflags="$aros_config_aflags" + aros_target_strip_flags="-R.comment --strip-debug" + aros_nominal_width=640 + aros_nominal_height=256 + aros_nominal_depth=2 + ;; + *ppc*) + aros_cpu="ppc" + aros_flavour="native" + gcc_target_cpu="ppc" + ;; + *) + as_fn_error $? "\"Unknown CPU for Amiga $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + mingw*) + aros_target_arch="mingw32" + aros_shared_default="no" + aros_flavour="emulation" + aros_shared_cflags="" + need_crosstools="yes" + need_dlopen="no" + rescomp="windres" + case "$target_cpu" in + *i?86*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="i386" + aros_object_format="elf_i386" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Di386" + aros_isa_flags="$""(ISA_X86_FLAGS)" + aros_nominal_depth=8 + gcc_target_cpu="i386" + + kernel_tool_prefix="i386-mingw32-" + ;; + *x86_64*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="x86_64" + aros_object_format="elf_x86_64" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dx86_64" + aros_isa_flags="$""(ISA_X8664_FLAGS)" + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_OMIT_FP)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_OMIT_FP)" + aros_nominal_depth=8 + kernel_tool_prefix="x86_64-w64-mingw32-" + ;; + *arm*) + PLATFORM_EXECSMP="#define __AROSPLATFORM_SMP__" + aros_target_cpu="arm" + aros_object_format="armelf_aros" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Darm" + aros_c_libs="$aros_c_libs -laeabi" + aros_nominal_depth=8 + gcc_target_cpu="arm" + gcc_default_float_abi="soft" + kernel_tool_prefix="arm-mingw32ce-" + aros_nominal_width=160 + aros_nominal_height=160 + ;; + *) + as_fn_error $? "\"Unknown CPU for Mingw32 -- $target_cpu\"" "$LINENO" 5 + ;; + esac + if test $host_os = "cygwin"; then + aros_kernel_cflags="-mno-cygwin" + fi + ;; + pp*) + aros_target_arch="pp" + aros_shared_default="no" + case "$target_cpu" in + *m68k*) + aros_target_cpu="m68k" + aros_object_format="m68kelf" + aros_flavour="palmnative" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dm68k" + aros_isa_flags="$""(ISA_MC68000_FLAGS)" + aros_nominal_width=160 + aros_nominal_height=160 + aros_nominal_depth=1 + aros_target_ar_flags="cru" + aros_c_libs="$aros_c_libs -lgcc1" + aros_shared_default=no + aros_shared_cflags="-fpic" + aros_shared_aflags="" + aros_shared_ldflags="-Wl,-rpath,./lib -shared" + aros_kernel_ldflags="-Wl,-rpath,./lib" + aros_debug_cppflags="$aros_messages_debug" + aros_debug_cflags="$aros_symbols_debug" + aros_debug_aflags="" + aros_debug_ldflags="$aros_symbols_debug" + aros_mungwall_debug="0" + aros_modules_debug="0" + gcc_target_cpu="mc68000" + ignore_undefined_symbols="-ius" + ;; + *) + as_fn_error $? "\"Unknown CPU for PalmPilot -- $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + mac*) + aros_target_arch="mac" + aros_shared_default="no" + case "$target_cpu" in + *m68k*) + aros_target_cpu="m68k" + aros_object_format="m68kelf" + aros_flavour="mac68knative" + aros_target_mkdep="$aros_target_mkdep -D__GNUC__ -Dm68k" + aros_isa_flags="$""(ISA_MC68000_FLAGS)" + aros_nominal_width=512 + aros_nominal_height=384 + aros_nominal_depth=8 + aros_target_ar_flags="cru" + aros_c_libs="$aros_c_libs -lgcc1" + aros_shared_default=no + aros_shared_cflags="-fpic" + aros_shared_aflags="" + aros_shared_ldflags="-Wl,-rpath,./lib -shared" + aros_kernel_ldflags="-Wl,-rpath,./lib" + aros_debug_cppflags="$aros_messages_debug" + aros_debug_cflags="$aros_symbols_debug" + aros_debug_aflags="" + aros_debug_ldflags="$aros_symbols_debug" + aros_mungwall_debug="0" + aros_modules_debug="0" + gcc_target_cpu="mc68000" + ignore_undefined_symbols="-ius" + ;; + *) + as_fn_error $? "\"Unknown CPU for Mac68k -- $target_cpu\"" "$LINENO" 5 + ;; + esac + ;; + + *) + as_fn_error $? "Unsupported target architecture $target" "$LINENO" 5 + ;; +esac + +#----------------------------------------------------------------------------- +crosstools_guess="yes" +aros_target_toolchain="no" +aros_kernel_sysroot="" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Kernel toolchain prefix" >&5 +$as_echo_n "checking Kernel toolchain prefix... " >&6; } + +# Check whether --with-kernel-toolchain-prefix was given. +if test "${with_kernel_toolchain_prefix+set}" = set; then : + withval=$with_kernel_toolchain_prefix; kernel_tool_prefix="$withval" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +$as_echo "$kernel_tool_prefix" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ELF toolchain prefix" >&5 +$as_echo_n "checking ELF toolchain prefix... " >&6; } + +# Check whether --with-elf-toolchain-prefix was given. +if test "${with_elf_toolchain_prefix+set}" = set; then : + withval=$with_elf_toolchain_prefix; elf_tool_prefix="$withval" + crosstools_guess="no" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $elf_tool_prefix" >&5 +$as_echo "$elf_tool_prefix" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS toolchain prefix" >&5 +$as_echo_n "checking AROS toolchain prefix... " >&6; } + +# Check whether --with-aros-toolchain was given. +if test "${with_aros_toolchain+set}" = set; then : + withval=$with_aros_toolchain; aros_tool_prefix="$withval" + crosstools_guess="no" +fi + +if test "$aros_tool_prefix" = "yes" ; then + aros_tool_prefix=$aros_target_cpu-aros- +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +$as_echo "$aros_tool_prefix" >&6; } + +#----------------------------------------------------------------------------- +# Checking if we should build crosstools.. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build crosstools" >&5 +$as_echo_n "checking whether to build crosstools... " >&6; } +# Check whether --enable-crosstools was given. +if test "${enable_crosstools+set}" = set; then : + enableval=$enable_crosstools; crosstools="$enableval" +else + crosstools="$crosstools_guess" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $crosstools" >&5 +$as_echo "$crosstools" >&6; } + +if test "${crosstools}" = "yes"; then + if test "${crosstools_guess}" = "no"; then + as_fn_error $? "Cannot build external toolchain if an external ELF or AROS toolchain is specified" "$LINENO" 5 + fi +fi + +if test "${crosstools}" = "yes" || test "${crosstools_guess}" = "no"; then + aros_target_toolchain="yes" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to install the crosstools binaries" >&5 +$as_echo_n "checking where to install the crosstools binaries... " >&6; } + +# Check whether --with-aros-toolchain-install was given. +if test "${with_aros_toolchain_install+set}" = set; then : + withval=$with_aros_toolchain_install; aros_toolchain_install=$withval +fi + +if test "x$aros_toolchain_install" = "x"; then + AROS_CROSSTOOLSDIR="$AROS_BUILDDIR_UNIX/bin/$aros_host_arch-$aros_host_cpu/tools/crosstools" +else + AROS_CROSSTOOLSDIR="$aros_toolchain_install" + PATH="$AROS_CROSSTOOLSDIR:$PATH" + if test "$crosstools_guess" = "no" ; then + if test "x-$aros_flavour" != "x-emulation" -a "x-$aros_flavour" != "x-emulcompat" ; then + aros_kernel_sysroot="$""(TARGET_SYSROOT)" + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_CROSSTOOLSDIR" >&5 +$as_echo "$AROS_CROSSTOOLSDIR" >&6; } + +#----------------------------------------------------------------------------- +if test "$aros_toolchain" = "gnu" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target binutils version to use" >&5 +$as_echo_n "checking what specific target binutils version to use... " >&6; } +fi + +# Check whether --with-binutils-version was given. +if test "${with_binutils_version+set}" = set; then : + withval=$with_binutils_version; use_binutils_version="$withval" +else + use_binutils_version="" +fi + +if test "$use_binutils_version" = ""; then + target_binutils_version="$default_binutils_version" +else + target_binutils_version="$use_binutils_version" +fi +if test "$aros_toolchain" = "gnu" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_binutils_version" >&5 +$as_echo "$target_binutils_version" >&6; } +fi + + +# Helper to identify gcc version + + +#----------------------------------------------------------------------------- +if test "$aros_toolchain" = "gnu" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target gcc version to use" >&5 +$as_echo_n "checking what specific target gcc version to use... " >&6; } +fi + +# Check whether --with-gcc-version was given. +if test "${with_gcc_version+set}" = set; then : + withval=$with_gcc_version; use_gcc_version="$withval" +else + use_gcc_version="" +fi + +if test "$use_gcc_version" = ""; then + if test "${crosstools}" = "no"; then + if test "x$aros_toolchain_install" != "x"; then + + target_gcc_version="" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5 +$as_echo_n "checking gcc version... " >&6; } +if ${ax_cv_gcc_version+:} false; then : + $as_echo_n "(cached) " >&6 +else + + ax_cv_gcc_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" + if test "x$ax_cv_gcc_version" = "x"; then : + + ax_cv_gcc_version="" + +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_gcc_version" >&5 +$as_echo "$ax_cv_gcc_version" >&6; } + target_gcc_version=$ax_cv_gcc_version + + + fi + fi + if test "$use_gcc_version" = ""; then + target_gcc_version="$default_gcc_version" + fi +else + target_gcc_version="$use_gcc_version" +fi +if test "$aros_toolchain" = "gnu" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_gcc_version" >&5 +$as_echo "$target_gcc_version" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking version string style" >&5 +$as_echo_n "checking version string style... " >&6; } + if test "${target_gcc_version#*$'-'}" != "$target_gcc_version" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: snapshot" >&5 +$as_echo "snapshot" >&6; } + GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'-' -f1) + GCC_VERSION_MINOR=-1 + GCC_VERSION_PATCH=-1 + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: release" >&5 +$as_echo "release" >&6; } + GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'.' -f1) + GCC_VERSION_MINOR=$(echo $target_gcc_version | cut -d'.' -f2) + GCC_VERSION_PATCH=$(echo $target_gcc_version | cut -d'.' -f3) + fi + + gcc_fix_bitfields="false" + if test "$GCC_VERSION_MAJOR" -gt "4" ; then + gcc_fix_bitfields="true" + else + if test "$GCC_VERSION_MAJOR" -gt "3" ; then + if test "$GCC_VERSION_MINOR" -gt "6" ; then + gcc_fix_bitfields="true" + fi + fi + fi + + if test "$GCC_VERSION_MAJOR" -lt "10" ; then + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_COMMON)" + fi + + if test "$gcc_fix_bitfields" = "true" ; then + case "$aros_target_cpu" in + *x86_64* | *i?86*) + x86_isa_extra="$x86_isa_extra $""(CFLAGS_NO_MS_BITFIELDS)" + x86_64_isa_extra="$x86_64_isa_extra $""(CFLAGS_NO_MS_BITFIELDS)" + ;; + esac + fi +fi + +# Helper to identify llvm version + + +if test "$aros_toolchain" = "llvm" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target llvm version to use" >&5 +$as_echo_n "checking what specific target llvm version to use... " >&6; } +fi + +# Check whether --with-llvm-version was given. +if test "${with_llvm_version+set}" = set; then : + withval=$with_llvm_version; use_llvm_version="$withval" +else + use_llvm_version="" +fi + +if test "$use_llvm_version" = ""; then + if test "${crosstools}" = "no"; then + if test "x$aros_toolchain_install" != "x"; then + + target_llvm_version="" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking llvm version" >&5 +$as_echo_n "checking llvm version... " >&6; } +if ${ax_cv_llvm_version+:} false; then : + $as_echo_n "(cached) " >&6 +else + + ax_cv_llvm_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" + if test "x$ax_cv_llvm_version" = "x"; then : + + ax_cv_llvm_version="" + +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_llvm_version" >&5 +$as_echo "$ax_cv_llvm_version" >&6; } + target_llvm_version=$ax_cv_llvm_version + + + fi + fi + if test "$use_llvm_version" = ""; then + target_llvm_version="$default_llvm_version" + fi +else + target_llvm_version="$use_llvm_version" +fi +if test "$aros_toolchain" = "llvm" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_llvm_version" >&5 +$as_echo "$target_llvm_version" >&6; } + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_COMMON)" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Objective-C suppport" >&5 +$as_echo_n "checking whether to enable Objective-C suppport... " >&6; } +# Check whether --enable-objc was given. +if test "${enable_objc+set}" = set; then : + enableval=$enable_objc; objc="$enableval" +else + objc="no" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $objc" >&5 +$as_echo "$objc" >&6; } +if test "x$objc" = "xyes"; then + objc_target="$objc" +else + objc_target="no-objc" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Java suppport" >&5 +$as_echo_n "checking whether to enable Java suppport... " >&6; } +# Check whether --enable-java was given. +if test "${enable_java+set}" = set; then : + enableval=$enable_java; java="$enableval" +else + java="no" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $java" >&5 +$as_echo "$java" >&6; } +if test "x$java" != "xno"; then + java_target="$java" +else + java_target="no-java" +fi + +spec_obj_format="-m $aros_object_format" +# Now process extra architecture-specific options. +# Currently this is implemented only for ARM. We can specify which minimum CPU and FPU to use,\ +# as well as floating-point ABI. +case "$aros_target_cpu" in + *m68k*) + gcc_default_cpu="68000" + aros_isa_targets="M68K_ISA_TARGETS :=MC68020 MC68040" + aros_isa_extra="$aros_isa_extra$export_newline$aros_isa_targets$export_newline" + aros_isa_extra="$aros_isa_extra$m68k_isa_extra$export_newline$m68k_020_isa_extra$export_newline$m68k_030_isa_extra$export_newline$m68k_040_isa_extra$export_newline$m68k_060_isa_extra$export_newline$m68k_ac080_isa_extra$export_newline" + aros_isa_extra="$aros_isa_extra$m68k_020_cppflags$export_newline$m68k_030_cppflags$export_newline$m68k_040_cppflags$export_newline$m68k_060_cppflags$export_newline" + aros_isa_extra="$aros_isa_extra$m68k_020_cflags$export_newline$m68k_030_cflags$export_newline$m68k_040_cflags$export_newline$m68k_060_cflags$export_newline" + aros_isa_extra="$aros_isa_extra$m68k_020_ldflags$export_newline$m68k_030_ldflags$export_newline$m68k_040_ldflags$export_newline$m68k_060_ldflags$export_newline" + aros_isa_extra="$aros_isa_extra$m68k_020_ext$export_newline$m68k_030_ext$export_newline$m68k_040_ext$export_newline$m68k_060_ext$export_newline" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +$as_echo_n "checking Which minimum CPU to use... " >&6; } + +# Check whether --with-cpu was given. +if test "${with_cpu+set}" = set; then : + withval=$with_cpu; aros_gcc_cpu="$withval" +else + aros_gcc_cpu=$gcc_default_cpu +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +$as_echo "$aros_gcc_cpu" >&6; } + if test "$gcc_default_cpu" != "$aros_gcc_cpu"; then + aros_target_cpu_extra=$aros_gcc_cpu + fi + aros_isa_flags="$""(ISA_MC"$aros_gcc_cpu"_FLAGS)" + ;; + *x86_64*) + aros_isa_extra="$export_newline$x86_isa_extra$export_newline$x86_64_isa_extra$export_newline" + spec_obj_format="%{!m32:-m elf_x86_64} %{m32:-m elf_i386}" + ;; + arm*) + aros_isa_extra="$export_newline$arm_isa_extra" + if test "$gcc_default_cpu" = ""; then + gcc_default_cpu="armv7-a+fp" + fi + + if test "$gcc_default_float_abi" = ""; then + if test "$target_cpu" = "armhf"; then + gcc_default_float_abi="hard" + if test "$gcc_default_fpu" = ""; then + gcc_default_fpu="vfpv3-d16" + fi + else + gcc_default_float_abi="softfp" + fi + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +$as_echo_n "checking Which minimum CPU to use... " >&6; } + +# Check whether --with-cpu was given. +if test "${with_cpu+set}" = set; then : + withval=$with_cpu; aros_gcc_cpu="$withval" +else + aros_gcc_cpu=$gcc_default_cpu +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +$as_echo "$aros_gcc_cpu" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum FPU to use" >&5 +$as_echo_n "checking Which minimum FPU to use... " >&6; } + +# Check whether --with-fpu was given. +if test "${with_fpu+set}" = set; then : + withval=$with_fpu; aros_gcc_fpu="$withval" +else + aros_gcc_fpu=$gcc_default_fpu +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_fpu" >&5 +$as_echo "$aros_gcc_fpu" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which floating point ABI to use" >&5 +$as_echo_n "checking Which floating point ABI to use... " >&6; } + +# Check whether --with-float was given. +if test "${with_float+set}" = set; then : + withval=$with_float; aros_gcc_float_abi="$withval" +else + aros_gcc_float_abi=$gcc_default_float_abi +fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_float_abi" >&5 +$as_echo "$aros_gcc_float_abi" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which ARM mode to use" >&5 +$as_echo_n "checking Which ARM mode to use... " >&6; } + if test "$aros_target_cpu_mode" = ""; then + aros_target_cpu_mode="arm32" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: Defaulting to $aros_target_cpu_mode" >&5 +$as_echo "Defaulting to $aros_target_cpu_mode" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cpu_mode" >&5 +$as_echo "$aros_target_cpu_mode" >&6; } + fi + + case "$aros_target_cpu_mode" in + arm32) + gcc_default_mode="arm" + aros_isa_extra="$aros_isa_extra -mthumb-interwork -march=$aros_gcc_cpu" + ;; + arm64) + as_fn_error $? "ARM 64-bit mode is unsupported" "$LINENO" 5 + ;; + thumb) + as_fn_error $? "Thumb1 16-bit mode is unsupported" "$LINENO" 5 + ;; + thumb1) + as_fn_error $? "Thumb1 16-bit mode is unsupported" "$LINENO" 5 + ;; + thumb2) + gcc_default_mode="thumb" + # Do not specify -mthumb-interwork as it may add extra code to support arm/thumb interwork + aros_isa_extra="$aros_isa_extra -march=$aros_gcc_cpu" + ;; + *) + as_fn_error $? "Unsupported ARM mode specified $aros_target_cpu_mode" "$LINENO" 5 + ;; + esac + + aros_isa_extra="$aros_isa_extra -mfpu=$gcc_default_fpu"$export_newline + + aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + aros_config_cxxflags="$aros_config_cxxflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + aros_config_aflags="$aros_config_aflags $""(CFLAGS_NO_ASYNCHRONOUS_UNWIND_TABLES) $""(CFLAGS_NO_EXCEPTIONS)" + ;; + i386) + aros_isa_extra="$x86_isa_extra$export_newline$x86_64_isa_extra$export_newline" + aros_kernel_ldflags="$aros_kernel_ldflags -m32" + ;; +esac + +# Some architectures may need custom ELF specs. +if test -f $SRCDIR/config/${aros_object_format}-specs.in; then + elf_specs_in=config/${aros_object_format}-specs.in +else + elf_specs_in=config/elf-specs.in +fi + +# Some compilers (ppc-elf-gcc is known to) have CPU defines in specs +# Since we override specs, we may need to put these defines there +if test "$gcc_target_cpu" != ""; then + gcc_target_cpu="-D__${gcc_target_cpu}__" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to download sourcecode for external ports" >&5 +$as_echo_n "checking where to download sourcecode for external ports... " >&6; } + +# Check whether --with-portssources was given. +if test "${with_portssources+set}" = set; then : + withval=$with_portssources; with_portssrcdir=$withval +else + with_portssrcdir="default" +fi + +if test "$with_portssrcdir" = "default"; then + AROS_PORTSSRCDIR="$AROS_BUILDDIR_UNIX/bin/Sources" +else + AROS_PORTSSRCDIR="$with_portssrcdir" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_PORTSSRCDIR" >&5 +$as_echo "$AROS_PORTSSRCDIR" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which bootloader to use" >&5 +$as_echo_n "checking which bootloader to use... " >&6; } + +# Check whether --with-bootloader was given. +if test "${with_bootloader+set}" = set; then : + withval=$with_bootloader; target_bootloader=$withval +else + target_bootloader=$target_bootloader +fi + +if test "$target_bootloader" = "none"; then + aros_target_bootloader="" +else + aros_target_bootloader="$target_bootloader" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_bootloader" >&5 +$as_echo "$target_bootloader" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which icon-set to use" >&5 +$as_echo_n "checking which icon-set to use... " >&6; } + +# Check whether --with-iconset was given. +if test "${with_iconset+set}" = set; then : + withval=$with_iconset; target_iconset=$withval +else + target_iconset="default" +fi + +if test "$target_iconset" = "default"; then + aros_target_iconset="Gorilla" + target_iconset="default (Gorilla)" +else + aros_target_iconset="$target_iconset" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_iconset" >&5 +$as_echo "$target_iconset" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which GUI Theme to use" >&5 +$as_echo_n "checking which GUI Theme to use... " >&6; } + +# Check whether --with-theme was given. +if test "${with_theme+set}" = set; then : + withval=$with_theme; target_guitheme=$withval +else + target_guitheme="default" +fi + +if test "$target_guitheme" = "default"; then + aros_target_guitheme="Ice" +else + aros_target_guitheme="$target_guitheme" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_guitheme" >&5 +$as_echo "$aros_target_guitheme" >&6; } + +# Find out if we are cross-compiling (i.e. if we can't use the host compiler +# for target code) +cross_compiling=no + +if test "$aros_host_cpu" != "$aros_target_cpu" ; then + cross_compiling=yes +fi + +if test "$aros_host_cpu" == "x86_64" ; then + if test "$aros_target_cpu" == "i386" ; then + cross_compiling=no + fi +fi + +if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" ; then + if test "$aros_host_arch" != "$aros_target_arch" ; then + cross_compiling=yes + fi +else + cross_compiling=yes + fi + +if test "$cross_compiling" = "no" ; then + kernel_tool_prefix="" + if test "$host_cc_elf" = "yes" ; then + elf_tool_prefix="" + fi +fi + +if test "$kernel_tool_version" != ""; then + kernel_tool_version="-$kernel_tool_version" +fi + +####################################################################### +## Compute what toolchains to use, and their paths ## +####################################################################### +# +# This takes, as input: +# crosstools {yes,no} +# kernel_tool_version {"",[version]} +# target_tool_version {"",[version]} +# kernel_tool_prefix {none,[some-arch-os-]} +# gnu-toolchain -: +# target_tool_prefix ${aros_target_cpu}-aros- +# aros_tool_prefix ${aros_target_cpu}-aros- +# +# The output is +# aros_kernel_{cpp,cc,ar,ld,as,ranlib,nm,strip} +# Where the 'kernel' binaries are located +# orig_target_{cpp,cc,ar,ld,as,ranlib,nm,strip} +# Where the 'target' binaries are located +# (not the symlink farm - that is aros_target_*!) +# +# The rules are: +# if crosstools then +# if kernel_tools_prefix = "no-kernel-prefix-" +# aros_kernel_* = crosstools cc paths +# aros_kernel_cc = elf cc wrapper around crosstools cc +# else +# VALIDATE(${kernel_tools_prefix}*) +# aros_kernel_* = ${kernel_tools_prefix}* +# if ${kernel_tools_prefix}cc is an AROS gcc +# aros_kernel_cc = ${kernel_tools_prefix}cc +# else +# aros_kernel_cc = elf cc wrapper around ${kernel_tools_prefix}cc +# fi +# fi +# +# orig_target_* = aros built crosstools +# orig_target_cc = elf cc wrapper around crosstools cc +# else +# VALIDATE(${kernel_tools_prefix}*) +# +# orig_target_* = aros_kernel_* +# if aros_kernel_cc is an AROS gcc +# orig_target_cc = aros_kernel_cc +# else +# orig_target_cc = aros cc wrapper around aros_kernel_cc +# fi +# fi +# +if test "$aros_toolchain" = "gnu" ; then + target_tool_prefix="${aros_target_cpu}-aros-" +elif test "$aros_toolchain" = "llvm" ; then + target_tool_prefix="bin/" +fi + +if test "$kernel_tool_prefix" != "" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking which kernel tools" >&5 +$as_echo_n "checking which kernel tools... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +$as_echo "$kernel_tool_prefix" >&6; }; +fi + +if test "$kernel_tool_prefix" = "none" ; then + if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" ; then + as_fn_error $? "--with-kernel-toolchain-prefix= is required for this arch" "$LINENO" 5 + fi +else + if test "x-$aros_flavour" != "x-standalone" -o "x-$aros_flavour" != "x-standcompat" ; then + # Kernel tools required - find them + # Note that 'normally', aros_kernel_* overrides will be + # empty, unless specified in the per-arch sections above. + test_kernel_cc=yes + if test "x$aros_kernel_cpp" = "x"; then + aros_kernel_cpp=${kernel_tool_prefix}${CPP_BASE} + fi + if test "${kernel_tool_version}" != ""; then + if test "$aros_kernel_cpp" != ""; then + ac_prog_args=`expr "X$aros_kernel_cpp" : '[^ ]* \(.*\)'` + ac_prog_cmd=`expr "X$aros_kernel_cpp" : '^\S*'` + aros_kernel_cpp="$ac_prog_cmd$${kernel_tool_version} $ac_prog_args" + fi +fi + +if test "$aros_kernel_cpp" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}cpp", so it can be a program name with args. +set dummy ${kernel_tool_prefix}cpp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp +if test -n "$aros_kernel_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +$as_echo "$aros_kernel_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_cpp=cpp +else + ac_tool_cpp= +fi +if test "$GCC" = "yes"; then + aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` + # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. +set dummy `basename $aros_gcc_cpp`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_cpp` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp +if test -n "$aros_kernel_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +$as_echo "$aros_kernel_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_cpp" = ""; then + for ac_prog in $ac_tool_cpp +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp +if test -n "$aros_kernel_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +$as_echo "$aros_kernel_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_cpp" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_cpp" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_cpp", so it can be a program name with args. +set dummy $aros_kernel_cpp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp +if test -n "$aros_kernel_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +$as_echo "$aros_kernel_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_cpp="$aros_kernel_cpp $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_cpp" = ""; then + req_avail=no +fi +if test "$aros_kernel_cpp" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cpp is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + if test "x$aros_kernel_cc" = "x"; then + aros_kernel_cc=${kernel_tool_prefix}${CC_BASE} + fi + if test "${kernel_tool_version}" != ""; then + if test "$aros_kernel_cc" != ""; then + ac_prog_args=`expr "X$aros_kernel_cc" : '[^ ]* \(.*\)'` + ac_prog_cmd=`expr "X$aros_kernel_cc" : '^\S*'` + aros_kernel_cc="$ac_prog_cmd$${kernel_tool_version} $ac_prog_args" + fi +fi + +if test "$aros_kernel_cc" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}cc", so it can be a program name with args. +set dummy ${kernel_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cc=$ac_cv_path_aros_kernel_cc +if test -n "$aros_kernel_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +$as_echo "$aros_kernel_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_cc=cc +else + ac_tool_cc= +fi +if test "$GCC" = "yes"; then + aros_gcc_cc=`$CC -print-prog-name=$ac_tool_cc` + # Extract the first word of "`basename $aros_gcc_[cc]`", so it can be a program name with args. +set dummy `basename $aros_gcc_cc`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_cc` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cc=$ac_cv_path_aros_kernel_cc +if test -n "$aros_kernel_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +$as_echo "$aros_kernel_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_cc" = ""; then + for ac_prog in $ac_tool_cc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cc=$ac_cv_path_aros_kernel_cc +if test -n "$aros_kernel_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +$as_echo "$aros_kernel_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_cc" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_cc" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_cc", so it can be a program name with args. +set dummy $aros_kernel_cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cc=$ac_cv_path_aros_kernel_cc +if test -n "$aros_kernel_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +$as_echo "$aros_kernel_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_cc="$aros_kernel_cc $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_cc" = ""; then + req_avail=no +fi +if test "$aros_kernel_cc" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cc is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + if test "x$aros_kernel_cxx" = "x"; then + aros_kernel_cxx=${kernel_tool_prefix}${CXX_BASE} + fi + if test "${kernel_tool_version}" != ""; then + if test "$aros_kernel_cxx" != ""; then + ac_prog_args=`expr "X$aros_kernel_cxx" : '[^ ]* \(.*\)'` + ac_prog_cmd=`expr "X$aros_kernel_cxx" : '^\S*'` + aros_kernel_cxx="$ac_prog_cmd$${kernel_tool_version} $ac_prog_args" + fi +fi + +if test "$aros_kernel_cxx" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}cxx", so it can be a program name with args. +set dummy ${kernel_tool_prefix}cxx; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx +if test -n "$aros_kernel_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +$as_echo "$aros_kernel_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_cxx=cxx +else + ac_tool_cxx= +fi +if test "$GCC" = "yes"; then + aros_gcc_cxx=`$CC -print-prog-name=$ac_tool_cxx` + # Extract the first word of "`basename $aros_gcc_[cxx]`", so it can be a program name with args. +set dummy `basename $aros_gcc_cxx`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_cxx` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx +if test -n "$aros_kernel_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +$as_echo "$aros_kernel_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_cxx" = ""; then + for ac_prog in $ac_tool_cxx +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx +if test -n "$aros_kernel_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +$as_echo "$aros_kernel_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_cxx" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_cxx" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_cxx", so it can be a program name with args. +set dummy $aros_kernel_cxx; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx +if test -n "$aros_kernel_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +$as_echo "$aros_kernel_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_cxx="$aros_kernel_cxx $ac_tool_optarg" +fi + + # If it's set, make sure it's really there + if test "x$aros_kernel_cxx" != "x" ; then + req_avail=yes +if test "$aros_kernel_cxx" = ""; then + req_avail=no +fi +if test "$aros_kernel_cxx" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cxx is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + fi + if test "x$aros_kernel_ld" = "x"; then + aros_kernel_ld=${kernel_tool_prefix}${LD_BASE} + fi + +if test "$aros_kernel_ld" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}ld", so it can be a program name with args. +set dummy ${kernel_tool_prefix}ld; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ld=$ac_cv_path_aros_kernel_ld +if test -n "$aros_kernel_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +$as_echo "$aros_kernel_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_ld=ld +else + ac_tool_ld= +fi +if test "$GCC" = "yes"; then + aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` + # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ld`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ld` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ld=$ac_cv_path_aros_kernel_ld +if test -n "$aros_kernel_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +$as_echo "$aros_kernel_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_ld" = ""; then + for ac_prog in $ac_tool_ld +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ld=$ac_cv_path_aros_kernel_ld +if test -n "$aros_kernel_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +$as_echo "$aros_kernel_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_ld" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_ld" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_ld", so it can be a program name with args. +set dummy $aros_kernel_ld; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ld=$ac_cv_path_aros_kernel_ld +if test -n "$aros_kernel_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +$as_echo "$aros_kernel_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_ld="$aros_kernel_ld $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_ld" = ""; then + req_avail=no +fi +if test "$aros_kernel_ld" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ld is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + if test "x$aros_kernel_as" = "x"; then + aros_kernel_as=$aros_host_as + if test "x$aros_kernel_as" = "x"; then + aros_kernel_as=${HOST_TOOLCHAIN_PREFIX}as${HOST_TOOLCHAIN_SUFFIX} + fi + fi + +if test "$aros_kernel_as" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}as", so it can be a program name with args. +set dummy ${kernel_tool_prefix}as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_as=$ac_cv_path_aros_kernel_as +if test -n "$aros_kernel_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +$as_echo "$aros_kernel_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_as=as +else + ac_tool_as= +fi +if test "$GCC" = "yes"; then + aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` + # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. +set dummy `basename $aros_gcc_as`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_as` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_as=$ac_cv_path_aros_kernel_as +if test -n "$aros_kernel_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +$as_echo "$aros_kernel_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_as" = ""; then + for ac_prog in $ac_tool_as +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_as=$ac_cv_path_aros_kernel_as +if test -n "$aros_kernel_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +$as_echo "$aros_kernel_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_as" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_as" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_as", so it can be a program name with args. +set dummy $aros_kernel_as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_as=$ac_cv_path_aros_kernel_as +if test -n "$aros_kernel_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +$as_echo "$aros_kernel_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_as="$aros_kernel_as $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_as" = ""; then + req_avail=no +fi +if test "$aros_kernel_as" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "as is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + if test "x$aros_kernel_ar" = "x"; then + aros_kernel_ar="${kernel_tool_prefix}${AR_BASE}" + fi + if test "${kernel_tool_version}" != ""; then + if test "$aros_kernel_ar" != ""; then + ac_prog_args=`expr "X$aros_kernel_ar" : '[^ ]* \(.*\)'` + ac_prog_cmd=`expr "X$aros_kernel_ar" : '^\S*'` + aros_kernel_ar="$ac_prog_cmd$${kernel_tool_version} $ac_prog_args" + fi +fi + +if test "$aros_kernel_ar" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}ar", so it can be a program name with args. +set dummy ${kernel_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ar=$ac_cv_path_aros_kernel_ar +if test -n "$aros_kernel_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +$as_echo "$aros_kernel_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_ar=ar +else + ac_tool_ar= +fi +if test "$GCC" = "yes"; then + aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` + # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ar`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ar` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ar=$ac_cv_path_aros_kernel_ar +if test -n "$aros_kernel_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +$as_echo "$aros_kernel_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_ar" = ""; then + for ac_prog in $ac_tool_ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ar=$ac_cv_path_aros_kernel_ar +if test -n "$aros_kernel_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +$as_echo "$aros_kernel_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_ar" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_ar" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_ar", so it can be a program name with args. +set dummy $aros_kernel_ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ar=$ac_cv_path_aros_kernel_ar +if test -n "$aros_kernel_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +$as_echo "$aros_kernel_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_ar="$aros_kernel_ar $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_ar" = ""; then + req_avail=no +fi +if test "$aros_kernel_ar" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ar is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + if test "x$aros_kernel_ranlib" = "x"; then + aros_kernel_ranlib=${kernel_tool_prefix}${RANLIB_BASE} + fi + if test "${kernel_tool_version}" != ""; then + if test "$aros_kernel_ranlib" != ""; then + ac_prog_args=`expr "X$aros_kernel_ranlib" : '[^ ]* \(.*\)'` + ac_prog_cmd=`expr "X$aros_kernel_ranlib" : '^\S*'` + aros_kernel_ranlib="$ac_prog_cmd$${kernel_tool_version} $ac_prog_args" + fi +fi + +if test "$aros_kernel_ranlib" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${kernel_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib +if test -n "$aros_kernel_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +$as_echo "$aros_kernel_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_ranlib=ranlib +else + ac_tool_ranlib= +fi +if test "$GCC" = "yes"; then + aros_gcc_ranlib=`$CC -print-prog-name=$ac_tool_ranlib` + # Extract the first word of "`basename $aros_gcc_[ranlib]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ranlib`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ranlib` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib +if test -n "$aros_kernel_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +$as_echo "$aros_kernel_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_ranlib" = ""; then + for ac_prog in $ac_tool_ranlib +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib +if test -n "$aros_kernel_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +$as_echo "$aros_kernel_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_ranlib" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_ranlib" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_ranlib", so it can be a program name with args. +set dummy $aros_kernel_ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib +if test -n "$aros_kernel_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +$as_echo "$aros_kernel_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_ranlib="$aros_kernel_ranlib $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_ranlib" = ""; then + req_avail=no +fi +if test "$aros_kernel_ranlib" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ranlib is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + if test "x$aros_kernel_nm" = "x"; then + aros_kernel_nm=$aros_host_nm + if test "x$aros_kernel_nm" = "x"; then + aros_kernel_nm=${HOST_TOOLCHAIN_PREFIX}nm${HOST_TOOLCHAIN_SUFFIX} + fi + fi + +if test "$aros_kernel_nm" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}nm", so it can be a program name with args. +set dummy ${kernel_tool_prefix}nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_nm=$ac_cv_path_aros_kernel_nm +if test -n "$aros_kernel_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +$as_echo "$aros_kernel_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_nm=nm +else + ac_tool_nm= +fi +if test "$GCC" = "yes"; then + aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` + # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. +set dummy `basename $aros_gcc_nm`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_nm` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_nm=$ac_cv_path_aros_kernel_nm +if test -n "$aros_kernel_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +$as_echo "$aros_kernel_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_nm" = ""; then + for ac_prog in $ac_tool_nm +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_nm=$ac_cv_path_aros_kernel_nm +if test -n "$aros_kernel_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +$as_echo "$aros_kernel_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_nm" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_nm" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_nm", so it can be a program name with args. +set dummy $aros_kernel_nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_nm=$ac_cv_path_aros_kernel_nm +if test -n "$aros_kernel_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +$as_echo "$aros_kernel_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_nm="$aros_kernel_nm $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_nm" = ""; then + req_avail=no +fi +if test "$aros_kernel_nm" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "nm is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "$aros_kernel_strip" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}strip", so it can be a program name with args. +set dummy ${kernel_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_strip=$ac_cv_path_aros_kernel_strip +if test -n "$aros_kernel_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +$as_echo "$aros_kernel_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_strip=strip +else + ac_tool_strip= +fi +if test "$GCC" = "yes"; then + aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` + # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. +set dummy `basename $aros_gcc_strip`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_strip` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_strip=$ac_cv_path_aros_kernel_strip +if test -n "$aros_kernel_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +$as_echo "$aros_kernel_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_strip" = ""; then + for ac_prog in $ac_tool_strip +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_strip=$ac_cv_path_aros_kernel_strip +if test -n "$aros_kernel_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +$as_echo "$aros_kernel_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_strip" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_strip" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_strip", so it can be a program name with args. +set dummy $aros_kernel_strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_strip=$ac_cv_path_aros_kernel_strip +if test -n "$aros_kernel_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +$as_echo "$aros_kernel_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_strip="$aros_kernel_strip $ac_tool_optarg" +fi + + req_avail=yes +if test "$aros_kernel_strip" = ""; then + req_avail=no +fi +if test "$aros_kernel_strip" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "strip is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + + # Objcopy and objdump are not required for the kernel + # toolchain on many architectures. + # So we'll look for them, but not make them strictly required. + if test "x$aros_kernel_objcopy" = "x"; then + aros_kernel_objcopy=$aros_host_objcopy + if test "x$aros_kernel_objcopy" = "x"; then + aros_kernel_objcopy=${HOST_TOOLCHAIN_PREFIX}objcopy${HOST_TOOLCHAIN_SUFFIX} + fi + fi + +if test "$aros_kernel_objcopy" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}objcopy", so it can be a program name with args. +set dummy ${kernel_tool_prefix}objcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy +if test -n "$aros_kernel_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +$as_echo "$aros_kernel_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_objcopy=objcopy +else + ac_tool_objcopy= +fi +if test "$GCC" = "yes"; then + aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` + # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. +set dummy `basename $aros_gcc_objcopy`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_objcopy` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy +if test -n "$aros_kernel_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +$as_echo "$aros_kernel_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_objcopy" = ""; then + for ac_prog in $ac_tool_objcopy +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy +if test -n "$aros_kernel_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +$as_echo "$aros_kernel_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_objcopy" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_objcopy" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_objcopy", so it can be a program name with args. +set dummy $aros_kernel_objcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy +if test -n "$aros_kernel_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +$as_echo "$aros_kernel_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_objcopy="$aros_kernel_objcopy $ac_tool_optarg" +fi + + if test "x$aros_kernel_objdump" = "x"; then + aros_kernel_objdump=$aros_host_objdump + if test "x$aros_kernel_objdump" = "x"; then + aros_kernel_objdump=${HOST_TOOLCHAIN_PREFIX}objdump${HOST_TOOLCHAIN_SUFFIX} + fi + fi + +if test "$aros_kernel_objdump" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${kernel_tool_prefix}objdump", so it can be a program name with args. +set dummy ${kernel_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump +if test -n "$aros_kernel_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +$as_echo "$aros_kernel_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_objdump=objdump +else + ac_tool_objdump= +fi +if test "$GCC" = "yes"; then + aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` + # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. +set dummy `basename $aros_gcc_objdump`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_objdump` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump +if test -n "$aros_kernel_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +$as_echo "$aros_kernel_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$aros_kernel_objdump" = ""; then + for ac_prog in $ac_tool_objdump +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump +if test -n "$aros_kernel_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +$as_echo "$aros_kernel_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$aros_kernel_objdump" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X$aros_kernel_objdump" : '[^ ]* \(.*\)'` + # Extract the first word of "$aros_kernel_objdump", so it can be a program name with args. +set dummy $aros_kernel_objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump +if test -n "$aros_kernel_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +$as_echo "$aros_kernel_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + aros_kernel_objdump="$aros_kernel_objdump $ac_tool_optarg" +fi + + if test "x${crosstools}" != "xyes" ; then + req_avail=yes +if test "$aros_kernel_objcopy" = ""; then + req_avail=no +fi +if test "$aros_kernel_objcopy" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "objcopy is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + req_avail=yes +if test "$aros_kernel_objdump" = ""; then + req_avail=no +fi +if test "$aros_kernel_objdump" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "objdump is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + fi + fi +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which target tools to use" >&5 +$as_echo_n "checking which target tools to use... " >&6; } +if test "$aros_target_toolchain" = "yes"; then + if test "$aros_toolchain" = "llvm" ; then + msg_result="llvm" + else + msg_result=$target_tool_prefix + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +$as_echo "$msg_result" >&6; } + # We are building AROS crosstools + tmp_tool_prefix="$AROS_CROSSTOOLSDIR/${target_tool_prefix}" + orig_target_cc="${tmp_tool_prefix}${toolchain_c_compiler}${target_tool_version}" + orig_target_cxx="${tmp_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" + orig_target_cpp="${tmp_tool_prefix}${toolchain_cpp_preprocessor}${toolchain_cpp_opts}" + orig_target_ld="${tmp_tool_prefix}${toolchain_ld}" + orig_target_as="${tmp_tool_prefix}${toolchain_as}" + orig_target_ar="${tmp_tool_prefix}${toolchain_ar}" + orig_target_ranlib="${tmp_tool_prefix}${toolchain_ranlib}" + orig_target_nm="${tmp_tool_prefix}${toolchain_nm}" + if ! test "$toolchain_strip" = "${NOP}"; then + orig_target_strip="${tmp_tool_prefix}${toolchain_strip}" + else + orig_target_strip="${toolchain_strip}" + fi + orig_target_objcopy="${tmp_tool_prefix}${toolchain_objcopy}" + orig_target_objdump="${tmp_tool_prefix}${toolchain_objdump}" +else + # Determine whether AROS or ELF tools should be used + if test "$aros_tool_prefix" = "none"; then + aros_tool_prefix="${elf_tool_prefix}" + fi + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +$as_echo "$aros_tool_prefix" >&6; } + # We are *not* building AROS crosstools - use the AROS or ELF tools + +if test "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}cpp", so it can be a program name with args. +set dummy ${target_tool_prefix}cpp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cpp=$ac_cv_path_orig_target_cpp +if test -n "$orig_target_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +$as_echo "$orig_target_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_cpp=cpp +else + ac_tool_cpp= +fi +if test "$GCC" = "yes"; then + aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` + # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. +set dummy `basename $aros_gcc_cpp`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_cpp` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cpp=$ac_cv_path_orig_target_cpp +if test -n "$orig_target_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +$as_echo "$orig_target_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_cpp" = ""; then + for ac_prog in $ac_tool_cpp +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cpp=$ac_cv_path_orig_target_cpp +if test -n "$orig_target_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +$as_echo "$orig_target_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_cpp" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cpp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cpp in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cpp=$ac_cv_path_orig_target_cpp +if test -n "$orig_target_cpp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +$as_echo "$orig_target_cpp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_cpp="$orig_target_cpp $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_cpp" = ""; then + req_avail=no +fi +if test "$orig_target_cpp" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cpp is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. +set dummy ${target_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cc=$ac_cv_path_orig_target_cc +if test -n "$orig_target_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +$as_echo "$orig_target_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_gcc=gcc +else + ac_tool_gcc= +fi +if test "$GCC" = "yes"; then + aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` + # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. +set dummy `basename $aros_gcc_gcc`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_gcc` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cc=$ac_cv_path_orig_target_cc +if test -n "$orig_target_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +$as_echo "$orig_target_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_cc" = ""; then + for ac_prog in $ac_tool_gcc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cc=$ac_cv_path_orig_target_cc +if test -n "$orig_target_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +$as_echo "$orig_target_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_cc" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cc+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cc in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cc=$ac_cv_path_orig_target_cc +if test -n "$orig_target_cc"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +$as_echo "$orig_target_cc" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_cc="$orig_target_cc $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_cc" = ""; then + req_avail=no +fi +if test "$orig_target_cc" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cc is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}g++", so it can be a program name with args. +set dummy ${target_tool_prefix}g++; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cxx=$ac_cv_path_orig_target_cxx +if test -n "$orig_target_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +$as_echo "$orig_target_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_g++=g++ +else + ac_tool_g++= +fi +if test "$GCC" = "yes"; then + aros_gcc_g++=`$CC -print-prog-name=$ac_tool_g++` + # Extract the first word of "`basename $aros_gcc_[g++]`", so it can be a program name with args. +set dummy `basename $aros_gcc_g++`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_g++` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cxx=$ac_cv_path_orig_target_cxx +if test -n "$orig_target_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +$as_echo "$orig_target_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_cxx" = ""; then + for ac_prog in $ac_tool_g++ +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cxx=$ac_cv_path_orig_target_cxx +if test -n "$orig_target_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +$as_echo "$orig_target_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_cxx" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_cxx+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_cxx in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_cxx=$ac_cv_path_orig_target_cxx +if test -n "$orig_target_cxx"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +$as_echo "$orig_target_cxx" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_cxx="$orig_target_cxx $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_cxx" = ""; then + req_avail=no +fi +if test "$orig_target_cxx" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "cxx is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_ld}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. +set dummy ${target_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ld=$ac_cv_path_orig_target_ld +if test -n "$orig_target_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +$as_echo "$orig_target_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_gcc=gcc +else + ac_tool_gcc= +fi +if test "$GCC" = "yes"; then + aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` + # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. +set dummy `basename $aros_gcc_gcc`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_gcc` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ld=$ac_cv_path_orig_target_ld +if test -n "$orig_target_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +$as_echo "$orig_target_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_ld" = ""; then + for ac_prog in $ac_tool_gcc +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ld=$ac_cv_path_orig_target_ld +if test -n "$orig_target_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +$as_echo "$orig_target_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_ld" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ld}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_ld}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_ld}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ld in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ld=$ac_cv_path_orig_target_ld +if test -n "$orig_target_ld"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +$as_echo "$orig_target_ld" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_ld="$orig_target_ld $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_ld" = ""; then + req_avail=no +fi +if test "$orig_target_ld" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ld is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "aros_tool_prefix}${toolchain_as}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}as", so it can be a program name with args. +set dummy ${target_tool_prefix}as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_as=$ac_cv_path_orig_target_as +if test -n "$orig_target_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +$as_echo "$orig_target_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_as=as +else + ac_tool_as= +fi +if test "$GCC" = "yes"; then + aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` + # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. +set dummy `basename $aros_gcc_as`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_as` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_as=$ac_cv_path_orig_target_as +if test -n "$orig_target_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +$as_echo "$orig_target_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_as" = ""; then + for ac_prog in $ac_tool_as +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_as=$ac_cv_path_orig_target_as +if test -n "$orig_target_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +$as_echo "$orig_target_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_as" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "Xaros_tool_prefix}${toolchain_as}" : '[^ ]* \(.*\)'` + # Extract the first word of "aros_tool_prefix}${toolchain_as}", so it can be a program name with args. +set dummy aros_tool_prefix}${toolchain_as}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_as+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_as in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_as=$ac_cv_path_orig_target_as +if test -n "$orig_target_as"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +$as_echo "$orig_target_as" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_as="$orig_target_as $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_as" = ""; then + req_avail=no +fi +if test "$orig_target_as" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "as is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_ar}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. +set dummy ${target_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ar=$ac_cv_path_orig_target_ar +if test -n "$orig_target_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +$as_echo "$orig_target_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_ar=ar +else + ac_tool_ar= +fi +if test "$GCC" = "yes"; then + aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` + # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ar`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ar` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ar=$ac_cv_path_orig_target_ar +if test -n "$orig_target_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +$as_echo "$orig_target_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_ar" = ""; then + for ac_prog in $ac_tool_ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ar=$ac_cv_path_orig_target_ar +if test -n "$orig_target_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +$as_echo "$orig_target_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_ar" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ar}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_ar}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_ar}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ar+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ar in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ar=$ac_cv_path_orig_target_ar +if test -n "$orig_target_ar"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +$as_echo "$orig_target_ar" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_ar="$orig_target_ar $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_ar" = ""; then + req_avail=no +fi +if test "$orig_target_ar" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ar is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_ranlib}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. +set dummy ${target_tool_prefix}ar; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ranlib=$ac_cv_path_orig_target_ranlib +if test -n "$orig_target_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +$as_echo "$orig_target_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_ar=ar +else + ac_tool_ar= +fi +if test "$GCC" = "yes"; then + aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` + # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. +set dummy `basename $aros_gcc_ar`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_ar` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ranlib=$ac_cv_path_orig_target_ranlib +if test -n "$orig_target_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +$as_echo "$orig_target_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_ranlib" = ""; then + for ac_prog in $ac_tool_ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ranlib=$ac_cv_path_orig_target_ranlib +if test -n "$orig_target_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +$as_echo "$orig_target_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_ranlib" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ranlib}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_ranlib}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_ranlib}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_ranlib+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_ranlib in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_ranlib=$ac_cv_path_orig_target_ranlib +if test -n "$orig_target_ranlib"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +$as_echo "$orig_target_ranlib" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_ranlib="$orig_target_ranlib $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_ranlib" = ""; then + req_avail=no +fi +if test "$orig_target_ranlib" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "ranlib is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_nm}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}nm", so it can be a program name with args. +set dummy ${target_tool_prefix}nm; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_nm=$ac_cv_path_orig_target_nm +if test -n "$orig_target_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +$as_echo "$orig_target_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_nm=nm +else + ac_tool_nm= +fi +if test "$GCC" = "yes"; then + aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` + # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. +set dummy `basename $aros_gcc_nm`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_nm` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_nm=$ac_cv_path_orig_target_nm +if test -n "$orig_target_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +$as_echo "$orig_target_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_nm" = ""; then + for ac_prog in $ac_tool_nm +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_nm=$ac_cv_path_orig_target_nm +if test -n "$orig_target_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +$as_echo "$orig_target_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_nm" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_nm}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_nm}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_nm}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_nm+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_nm in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_nm=$ac_cv_path_orig_target_nm +if test -n "$orig_target_nm"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +$as_echo "$orig_target_nm" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_nm="$orig_target_nm $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_nm" = ""; then + req_avail=no +fi +if test "$orig_target_nm" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "nm is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + if ! test "$toolchain_strip" = "${NOP}"; then + +if test "${aros_tool_prefix}${toolchain_strip}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}strip", so it can be a program name with args. +set dummy ${target_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_strip=$ac_cv_path_orig_target_strip +if test -n "$orig_target_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +$as_echo "$orig_target_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_strip=strip +else + ac_tool_strip= +fi +if test "$GCC" = "yes"; then + aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` + # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. +set dummy `basename $aros_gcc_strip`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_strip` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_strip=$ac_cv_path_orig_target_strip +if test -n "$orig_target_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +$as_echo "$orig_target_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_strip" = ""; then + for ac_prog in $ac_tool_strip +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_strip=$ac_cv_path_orig_target_strip +if test -n "$orig_target_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +$as_echo "$orig_target_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_strip" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_strip}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_strip}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_strip}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_strip+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_strip in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_strip=$ac_cv_path_orig_target_strip +if test -n "$orig_target_strip"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +$as_echo "$orig_target_strip" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_strip="$orig_target_strip $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_strip" = ""; then + req_avail=no +fi +if test "$orig_target_strip" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "strip is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + else + orig_target_strip="${toolchain_strip}" + fi + +if test "${aros_tool_prefix}${toolchain_objcopy}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}objcopy", so it can be a program name with args. +set dummy ${target_tool_prefix}objcopy; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objcopy=$ac_cv_path_orig_target_objcopy +if test -n "$orig_target_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +$as_echo "$orig_target_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_objcopy=objcopy +else + ac_tool_objcopy= +fi +if test "$GCC" = "yes"; then + aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` + # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. +set dummy `basename $aros_gcc_objcopy`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_objcopy` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objcopy=$ac_cv_path_orig_target_objcopy +if test -n "$orig_target_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +$as_echo "$orig_target_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_objcopy" = ""; then + for ac_prog in $ac_tool_objcopy +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objcopy=$ac_cv_path_orig_target_objcopy +if test -n "$orig_target_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +$as_echo "$orig_target_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_objcopy" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objcopy}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_objcopy}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_objcopy}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objcopy+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objcopy in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objcopy=$ac_cv_path_orig_target_objcopy +if test -n "$orig_target_objcopy"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +$as_echo "$orig_target_objcopy" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_objcopy="$orig_target_objcopy $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_objcopy" = ""; then + req_avail=no +fi +if test "$orig_target_objcopy" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "objcopy is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi + +if test "${aros_tool_prefix}${toolchain_objdump}" = ""; then + if test "$cross_compiling" = "yes" ; then + # Extract the first word of "${target_tool_prefix}objdump", so it can be a program name with args. +set dummy ${target_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objdump=$ac_cv_path_orig_target_objdump +if test -n "$orig_target_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +$as_echo "$orig_target_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + +if test "" = ""; then + ac_tool_objdump=objdump +else + ac_tool_objdump= +fi +if test "$GCC" = "yes"; then + aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` + # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. +set dummy `basename $aros_gcc_objdump`; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in `dirname $aros_gcc_objdump` +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objdump=$ac_cv_path_orig_target_objdump +if test -n "$orig_target_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +$as_echo "$orig_target_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test "$orig_target_objdump" = ""; then + for ac_prog in $ac_tool_objdump +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objdump=$ac_cv_path_orig_target_objdump +if test -n "$orig_target_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +$as_echo "$orig_target_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$orig_target_objdump" && break +done + +fi + + fi +else + ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objdump}" : '[^ ]* \(.*\)'` + # Extract the first word of "${aros_tool_prefix}${toolchain_objdump}", so it can be a program name with args. +set dummy ${aros_tool_prefix}${toolchain_objdump}; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_orig_target_objdump+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $orig_target_objdump in + [\\/]* | ?:[\\/]*) + ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +orig_target_objdump=$ac_cv_path_orig_target_objdump +if test -n "$orig_target_objdump"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +$as_echo "$orig_target_objdump" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + orig_target_objdump="$orig_target_objdump $ac_tool_optarg" +fi + + req_avail=yes +if test "$orig_target_objdump" = ""; then + req_avail=no +fi +if test "$orig_target_objdump" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "objdump is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +fi + +if test "$kernel_tool_prefix" = "none" ; then + # No kernel tools specified + # Assume kernel tools == target tools with ELF wrapper + aros_kernel_cc=$orig_target_cc + aros_kernel_cxx=$orig_target_cxx + aros_kernel_cpp="$orig_target_cpp" + aros_kernel_ld=$orig_target_ld + aros_kernel_as=$orig_target_as + aros_kernel_ar=$orig_target_ar + aros_kernel_ranlib=$orig_target_ranlib + aros_kernel_nm=$orig_target_nm + aros_kernel_strip=$orig_target_strip + aros_kernel_objcopy=$orig_target_objcopy + aros_kernel_objdump=$orig_target_objdump + aros_kernel_isa_flags="$""(ISA_FLAGS)" + use_kernel_cc_wrapper=yes +fi + +# At this point, all aros_kernel_* and aros_target_* +# tools should be set up correctly + +CC="$aros_kernel_cc $kernel_tool_flags" +CPP="$aros_kernel_cpp" + +#----------------------------------------------------------------------------- + +# Find all the tools we need to compile. This could be cross-compiling +# though! If that is the case we use the GNU form of the target and +# simply add this to the front of the binary name. This is rather simple, +# but it should work under most circumstances. +# +# The default tools are to use the same as the host, but only if the +# host and target CPU are the same. With GCC this is normally enough. +# + +aros_cc_pre="" +aros_shared_ld="$aros_host_ld" + +aros_target_mkdep="$aros_host_mkdep" + +# The default tools executables to be linked to. +if test "$rescomp" != ""; then + # Extract the first word of "${kernel_tool_prefix}$rescomp", so it can be a program name with args. +set dummy ${kernel_tool_prefix}$rescomp; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_aros_kernel_rescomp+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $aros_kernel_rescomp in + [\\/]* | ?:[\\/]*) + ac_cv_path_aros_kernel_rescomp="$aros_kernel_rescomp" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_aros_kernel_rescomp="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; +esac +fi +aros_kernel_rescomp=$ac_cv_path_aros_kernel_rescomp +if test -n "$aros_kernel_rescomp"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_rescomp" >&5 +$as_echo "$aros_kernel_rescomp" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + req_avail=yes +if test "$aros_kernel_rescomp" = ""; then + req_avail=no +fi +if test "$aros_kernel_rescomp" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "$rescomp is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi +fi + +# Set up the sources for the symlink farm +if test "$crosstools" = "yes"; then + crosstools_target=tools-crosstools +fi + +aros_kernel_cc="$aros_kernel_cc $kernel_tool_flags" +aros_kernel_ar="$aros_kernel_ar $aros_kernel_ar_flags" + +aros_hostcfg_dir="bin/${aros_host_arch}-${aros_host_cpu}/gen/host/config" +aros_targetcfg_dir="bin/${aros_target_arch}-${aros_target_cpu}${aros_target_suffix}/gen/config" +aros_inc_dir="bin/${aros_target_arch}-${aros_target_cpu}${aros_target_suffix}/AROS/Developer/include/aros" +aros_gendir="bin/${aros_target_arch}-${aros_target_cpu}${aros_target_suffix}/gen" +aros_geninc_dir="bin/${aros_target_arch}-${aros_target_cpu}${aros_target_suffix}/gen/include/aros" +aros_tools_dir="bin/${aros_host_arch}-${aros_host_cpu}/tools" +aros_scripts_dir="bin/${aros_target_arch}-${aros_target_cpu}${aros_target_suffix}/gen/scripts" + +# aros_cc_pre is a variable that is added to the front of the compiler name +# in the generated aros-gcc shell script. We need this to enable the cache +# to work across cleaned builds. Also, support DISTCC using the correct +# environment variable. +# + +if test "x${DISTCC}" != "x" ; then + if test "x${CCACHE}" != "x" ; then + aros_cc_pre="env CCACHE_PREFIX=${DISTCC} ${CCACHE} " + else + aros_cc_pre="${DISTCC} " + fi +else + if test "x${CCACHE}" != "x" ; then + aros_cc_pre="${CCACHE} " + fi +fi + +aros_target_nostdinc_cflags=-nostdinc + +aros_target_nostartup_ldflags=-nostartfiles + +aros_target_nix_ldflags=-nix + +aros_target_detach_ldflags=-detach + +aros_target_nostdlib_ldflags=-nostdlib + + +aros_target_cc_path= + +# Target tools + +if test "$aros_target_toolchain" != "yes"; then + prefix="${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-" + if test "$GCC" = "yes"; then + aros_target_cc_path=`$orig_target_cc -print-search-dirs | grep "programs: =" | cut -c 12-` + fi +else + # We do not know which c compiler version we are going to build and what we need to know + # here is different for different versions so this will be set later during the + # build of crosstools. + if test "$aros_toolchain" = "gnu" ; then + prefix="$AROS_CROSSTOOLSDIR/${aros_target_cpu}-aros-" + elif test "$aros_toolchain" = "llvm" ; then + prefix="$AROS_CROSSTOOLSDIR/bin/" + fi + aros_target_cc_path=@aros_target_cc_path@ +fi +aros_target_cpp="${prefix}${toolchain_cpp_preprocessor}${toolchain_cpp_opts}" +aros_target_cc="${prefix}${toolchain_c_compiler}" +aros_target_cxx="${prefix}${toolchain_cxx_compiler}" +aros_target_as="${prefix}${toolchain_as}" +if test "${use_ld_wrapper}" = "yes"; then + aros_target_ld="${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${aros_ld}" +else + aros_target_ld="${prefix}${toolchain_ld}" +fi +aros_toolchain_ld="${prefix}${toolchain_ld}" + +aros_target_ar="${prefix}${toolchain_ar} $aros_target_ar_flags" +aros_target_objcopy="${prefix}${toolchain_objcopy}" +aros_target_objdump="${prefix}${toolchain_objdump}" +aros_target_ranlib="${prefix}${toolchain_ranlib} $aros_target_ranlib_flags" +aros_target_nm="${prefix}${toolchain_nm} $aros_target_nm_flags" +if ! test "$toolchain_strip" = "${NOP}"; then + aros_target_strip="${prefix}${toolchain_strip}" +else + aros_target_strip="${toolchain_strip}" +fi +aros_plain_nm="${prefix}${toolchain_nm}" +aros_plain_ar="${prefix}${toolchain_ar}" + +# Check whether --enable-includes was given. +if test "${enable_includes+set}" = set; then : + enableval=$enable_includes; aros_target_incl=$enable_includes +else + aros_target_incl=no +fi + + +if test "x$aros_target_incl" = "xno"; then + if test "x$test_kernel_cc" != "xno"; then + aros_target_incl=`$aros_kernel_cc -print-sysroot 2>/dev/null`/`$aros_kernel_cc --print-sysroot-headers-suffix 2>/dev/null || echo usr/include` + else + aros_target_incl= + fi +fi + +if test "x$aros_kernel_includes" = "x"; then + if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" ; then + if test "x$aros_target_incl" != "x"; then + aros_kernel_includes="-isystem $aros_target_incl" + fi + fi +fi + +if test "x$test_kernel_cc" != "xno"; then + if test "$aros_kernel_includes" != "" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the kernel compiler's include path" >&5 +$as_echo_n "checking for the kernel compiler's include path... " >&6; } + if test "$aros_kernel_cc_includes" = "" ; then + # Try to guess where the directory is. + aros_kernel_cc_includes=`dirname \`${aros_kernel_cc} ${aros_kernel_cflags} -print-libgcc-file-name\``/include + if test -d $aros_kernel_cc_includes; then + # Check if there is also an include-fixed directory and add it + # to kernel compiler's include path as it may contain some of + # the headers we need. + if test -d "$aros_kernel_cc_includes"-fixed; then + aros_kernel_cc_includes+=" -isystem $aros_kernel_cc_includes"-fixed + fi + # Check for specific includes directory. Needed for Ubuntu 11.10 and Debian + if test -d "/usr/include/${aros_target_cpu}-linux-gnu"; then + aros_kernel_cc_includes+=" -isystem /usr/include/${aros_target_cpu}-linux-gnu" + fi + else + # The directory doesn't exist, we need to do some more work. + aros_kernel_cc_includes=${PWD}/${aros_gendir}/cc_include + + # These are the headers we're looking for. + headers="limits.h mmintrin.h stdbool.h syslimits.h float.h \ + stddef.h xmmintrin.h iso646.h stdarg.h unwind.h \ + zutil.h stdint.h" + + dirs= + for h in $headers; do + # Which other headers are needed by each of the above? + deps=$(echo "#include <$h>" | \ + $aros_kernel_cc -E -M - 2>/dev/null | \ + sed 's/^.*://; s/\\$/ /g; s/[ \t]\+/ /g') + + # Copy all the needed headers to a directory beneath gendir. + for d in $deps; do + h=$(basename $d) + dir=${aros_kernel_cc_includes}$(echo $(dirname $d) | \ + sed -n "s,^.*/include\(/.*\),\1,p") + ! test -d $dir && mkdir -p $dir + ! test -f $dir/$h && { cp $d $dir; chmod u+w $dir/$h; } + done + done + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc_includes" >&5 +$as_echo "$aros_kernel_cc_includes" >&6; } + # Adding -nostdinc to kernel includes as they are always used together. + aros_kernel_includes="$aros_kernel_includes $aros_target_nostdinc_cflags -isystem $aros_kernel_cc_includes" + fi +fi + +if test "$crosstools" != "yes"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the target compiler's include path" >&5 +$as_echo_n "checking for the target compiler's include path... " >&6; } + if test "$aros_target_cc_includes" = "" ; then + #try to guess where the directory is + aros_target_cc_includes=`dirname \`${orig_target_cc} -print-libgcc-file-name\``/include + if ! test -d $aros_target_cc_includes; then + #the directory doesn't exist, we need to do some more work + aros_target_cc_includes=${PWD}/${aros_gendir}/cc_include + + #these are the headers we're looking for + headers="limits.h mmintrin.h stdbool.h syslimits.h float.h \ + stddef.h xmmintrin.h iso646.h stdarg.h unwind.h \ + zutil.h" + + dirs= + for h in $headers; do + #which other headers each of the above headers needs? + deps=$(echo "#include <$h>" | \ + $orig_target_cc -E -M - 2>/dev/null | \ + sed 's/^.*://; s/\\$/ /g; s/[ \t]\+/ /g') + + #copy all the needed headers to a directory beneath gendir + for d in $deps; do + h=$(basename $d) + dir=${aros_target_cc_includes}$(echo $(dirname $d) | \ + sed -n "s,^.*/include\(/.*\),\1,p") + ! test -d $dir && mkdir -p $dir + ! test -f $dir/$h && { cp $d $dir; chmod u+w $dir/$h; } + done + done + fi + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cc_includes" >&5 +$as_echo "$aros_target_cc_includes" >&6; } +else + # We do not know which c compiler version we are going to build and what we need to know + # here is different for different versions so this will be set later during the + # build of crosstools. + aros_target_cc_includes=@aros_target_cc_includes@ +fi + +# +# For GCC < 4.0 -I- is used for giving the search path for '#include "..."' +# On GCC >= 4.0 -iquote should be used +# + +save_cc="$CC" +save_cflags="$CFLAGS" +if test "x$test_kernel_cc" != "xno"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: Testing kernel compiler..." >&5 +$as_echo "$as_me: Testing kernel compiler..." >&6;} + CFLAGS="-iquote." + kernel_cflags_iquote=$host_cflags_iquote + kernel_cflags_iquote_end=$host_cflags_iquote_end + if test "x-$cross_compiling" = "x-yes"; then + CC="$aros_kernel_cc" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fno-stack-protector" >&5 +$as_echo_n "checking whether ${CC} accepts -fno-stack-protector... " >&6; } + if test "x-$crosstools" != "x-yes"; then + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + use_no_stack_protector="yes" +else + use_no_stack_protector="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + else + # we do know it is supported for the smallest version of gcc we are going to build + # we assume it's also supported by later versions + use_no_stack_protector=yes + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +$as_echo "$use_no_stack_protector" >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -iquote" >&5 +$as_echo_n "checking whether ${CC} accepts -iquote... " >&6; } + if test "x-$crosstools" != "x-yes"; then + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + has_iquote="yes" +else + has_iquote="no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + else + # we do know it is supported for the smallest version of gcc we are going to build + # we assume it's also supported by later versions + has_iquote=yes + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +$as_echo "$has_iquote" >&6; } + if test "x-$has_iquote" = "x-yes" ; then + kernel_cflags_iquote=-iquote + kernel_cflags_iquote_end= + else + kernel_cflags_iquote=-I + kernel_cflags_iquote_end=-I- + fi + fi + if test "x-$use_no_common" = "x-yes" ; then + aros_kernel_cflags="$aros_kernel_cflags -fno-common" + fi + if test "x-$use_no_stack_protector" = "x-yes" ; then + aros_kernel_cflags="$aros_kernel_cflags -fno-stack-protector" + fi + + #----------------------------------------------------------------------------- + + # Check if we can explicitly choose older version of symbol hashing + + CFLAGS="$save_cflags -Wl,--hash-style=sysv" + CC="$aros_kernel_cc" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -Wl,--hash-style=sysv" >&5 +$as_echo_n "checking whether ${CC} accepts -Wl,--hash-style=sysv... " >&6; } + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + use_hash_style="yes" +else + use_hash_style="no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_hash_style" >&5 +$as_echo "$use_hash_style" >&6; } + if test "x-$use_hash_style" = "x-yes" ; then + aros_kernel_cflags="$aros_kernel_cflags -Wl,--hash-style=sysv" + fi +else + kernel_cflags_iquote="$""(CFLAGS_IQUOTE)" + kernel_cflags_iquote_end="$""(CFLAGS_IQUOTE_END)" +fi +CC="$save_cc" +CFLAGS="$save_cflags" + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for default resolution of WBScreen" >&5 +$as_echo_n "checking for default resolution of WBScreen... " >&6; } + +# Check whether --with-resolution was given. +if test "${with_resolution+set}" = set; then : + withval=$with_resolution; resolution=$withval +else + resolution=none +fi + +# We require an argument, so map --with/--without ("yes"/"no") to "none" specified +if test "$resolution" = "yes" ; then + resolution="none" +fi +if test "$resolution" = "no" ; then + resolution="none" +fi +if test "$resolution" != "none" ; then + aros_nominal_width=`echo $resolution | cut -d'x' -f1` + aros_nominal_height=`echo $resolution | cut -d'x' -f2` + aros_nominal_depth=`echo $resolution | cut -d'x' -f3` +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&5 +$as_echo "$aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&6; } +aros_cv_nominal_width=$aros_nominal_width +aros_cv_nominal_height=$aros_nominal_height +aros_cv_nominal_depth=$aros_nominal_depth + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are compiling for non-vampires --with-nonvampire-support " >&5 +$as_echo_n "checking whether we are compiling for non-vampires --with-nonvampire-support ... " >&6; } + +# Check whether --with-nonvampire-support was given. +if test "${with_nonvampire_support+set}" = set; then : + withval=$with_nonvampire_support; nonvampire_support=$withval +else + nonvampire_support=none +fi + +if test "$nonvampire_support" = "yes"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: Enabling nonvampire support" >&5 +$as_echo "Enabling nonvampire support" >&6; } + aros_config_cppflags="$aros_config_cppflags -DNONVAMPIRE" + aros_config_cflags="$aros_config_cflags -DNONVAMPIRE" + aros_kernel_cppflags="$aros_kernel_cppflags -DNONVAMPIRE" + aros_kernel_cflags="$aros_kernel_cflags -DNONVAMPIRE" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 +$as_echo_n "checking Vampire card series: v2 or v4 ... " >&6; } + +# Check whether --with-vampirecard-series was given. +if test "${with_vampirecard_series+set}" = set; then : + withval=$with_vampirecard_series; vampirecard_series="$withval" +else + vampirecard_Series="v4" +fi + +if test "$vampirecard_series" = "v2" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v2 " >&5 +$as_echo "Vampire Card Series v2 " >&6; } + aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=2" + aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=2" + aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=2" + aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=2" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v4 " >&5 +$as_echo "Vampire Card Series v4 " >&6; } + aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=4" + aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=4" + aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=4" + aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=4" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether serial debug is enabled" >&5 +$as_echo_n "checking whether serial debug is enabled... " >&6; } + +# Check whether --with-serial-debug was given. +if test "${with_serial_debug+set}" = set; then : + withval=$with_serial_debug; serial_debug=$withval +else + serial_debug=none +fi + +if test "$aros_serial_debug" = 0 ; then + serial_debug_forced="" + if test "$serial_debug" = "yes" ; then + serial_debug="1" + fi + if test "$serial_debug" = "no" ; then + serial_debug="none" + fi +else + serial_debug_forced="(forced)" + serial_debug=$aros_serial_debug +fi +if test "$serial_debug" != "none" ; then + aros_serial_debug=$serial_debug + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $serial_debug_forced on port $serial_debug" >&5 +$as_echo "$serial_debug_forced on port $serial_debug" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether palm debug hack is enabled" >&5 +$as_echo_n "checking whether palm debug hack is enabled... " >&6; } +# Check whether --enable-palm_debug_hack was given. +if test "${enable_palm_debug_hack+set}" = set; then : + enableval=$enable_palm_debug_hack; palm_debug_hack="yes" +else + palm_debug_hack="no" +fi + +if test "$palm_debug_hack" = "yes" ; then + aros_palm_debug_hack="1" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $palm_debug_hack" >&5 +$as_echo "$palm_debug_hack" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether usb3.0 code is enabled" >&5 +$as_echo_n "checking whether usb3.0 code is enabled... " >&6; } +# Check whether --enable-usb30_code was given. +if test "${enable_usb30_code+set}" = set; then : + enableval=$enable_usb30_code; usb30_code="yes" +else + usb30_code="no" +fi + +if test "$usb30_code" = "yes" ; then + aros_config_cppflags="$aros_config_cppflags -DAROS_USB30_CODE" + aros_kernel_cflags="$aros_kernel_cflags -DAROS_USB30_CODE" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $usb30_code" >&5 +$as_echo "$usb30_code" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether nesting supervisor support is enabled" >&5 +$as_echo_n "checking whether nesting supervisor support is enabled... " >&6; } +# Check whether --enable-nesting_supervisor was given. +if test "${enable_nesting_supervisor+set}" = set; then : + enableval=$enable_nesting_supervisor; nesting_supervisor="yes" +else + nesting_supervisor="no" +fi + +if test "$nesting_supervisor" = "yes" ; then + aros_nesting_supervisor="1" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $nesting_supervisor" >&5 +$as_echo "$nesting_supervisor" >&6; } + +if test "$aros_enable_mmu" = "" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether MMU support is enabled" >&5 +$as_echo_n "checking whether MMU support is enabled... " >&6; } + # Check whether --enable-mmu was given. +if test "${enable_mmu+set}" = set; then : + enableval=$enable_mmu; aros_enable_mmu=$enableval +else + aros_enable_mmu="yes" +fi + + if test "$aros_enable_mmu" = "" ; then + aros_enable_mmu="yes" + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_enable_mmu" >&5 +$as_echo "$aros_enable_mmu" >&6; } +fi +if test "$aros_enable_mmu" = "no" ; then + aros_enable_mmu="0" +else + aros_enable_mmu="1" +fi + + +if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" ; then + + if test "x-$need_dlopen" != "x-no" ; then + save_libs="$LIBS" + LIBS="" + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + have_dl="yes" +else + have_dl="no" +fi + + if test "x-$have_dl" = "x-no" ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + have_dl="yes" + aros_host_ldflags="$aros_host_ldflags -ldl" +else + have_dl="no" +fi + + fi + if test "x-$have_dl" = "x-no" ; then + as_fn_error $? "dlopen() dynamic linker functions not available" "$LINENO" 5 + fi + LIBS="$save_libs" + fi + + + # Check whether --enable-x11_hidd was given. +if test "${enable_x11_hidd+set}" = set; then : + enableval=$enable_x11_hidd; x11_hidd="$enableval" +else + x11_hidd="$need_x11" +fi + + case "x-$x11_hidd" in + x-yes|x-no|x-auto) ;; + *) x11_hidd="$need_x11" ;; + esac + + ENABLE_X11=0 + + if test "x-$x11_hidd" != "x-no" ; then + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 +$as_echo_n "checking for X... " >&6; } + + +# Check whether --with-x was given. +if test "${with_x+set}" = set; then : + withval=$with_x; +fi + +# $have_x is `yes', `no', `disabled', or empty when we do not yet know. +if test "x$with_x" = xno; then + # The user explicitly disabled X. + have_x=disabled +else + case $x_includes,$x_libraries in #( + *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #( + *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then : + $as_echo_n "(cached) " >&6 +else + # One or both of the vars are not set, and there is no cached value. +ac_x_includes=no ac_x_libraries=no +rm -f -r conftest.dir +if mkdir conftest.dir; then + cd conftest.dir + cat >Imakefile <<'_ACEOF' +incroot: + @echo incroot='${INCROOT}' +usrlibdir: + @echo usrlibdir='${USRLIBDIR}' +libdir: + @echo libdir='${LIBDIR}' +_ACEOF + if (export CC; ${XMKMF-xmkmf}) >/dev/null 2>/dev/null && test -f Makefile; then + # GNU make sometimes prints "make[1]: Entering ...", which would confuse us. + for ac_var in incroot usrlibdir libdir; do + eval "ac_im_$ac_var=\`\${MAKE-make} $ac_var 2>/dev/null | sed -n 's/^$ac_var=//p'\`" + done + # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR. + for ac_extension in a so sl dylib la dll; do + if test ! -f "$ac_im_usrlibdir/libX11.$ac_extension" && + test -f "$ac_im_libdir/libX11.$ac_extension"; then + ac_im_usrlibdir=$ac_im_libdir; break + fi + done + # Screen out bogus values from the imake configuration. They are + # bogus both because they are the default anyway, and because + # using them would break gcc on systems where it needs fixed includes. + case $ac_im_incroot in + /usr/include) ac_x_includes= ;; + *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes=$ac_im_incroot;; + esac + case $ac_im_usrlibdir in + /usr/lib | /usr/lib64 | /lib | /lib64) ;; + *) test -d "$ac_im_usrlibdir" && ac_x_libraries=$ac_im_usrlibdir ;; + esac + fi + cd .. + rm -f -r conftest.dir +fi + +# Standard set of common directories for X headers. +# Check X11 before X11Rn because it is often a symlink to the current release. +ac_x_header_dirs=' +/usr/X11/include +/usr/X11R7/include +/usr/X11R6/include +/usr/X11R5/include +/usr/X11R4/include + +/usr/include/X11 +/usr/include/X11R7 +/usr/include/X11R6 +/usr/include/X11R5 +/usr/include/X11R4 + +/usr/local/X11/include +/usr/local/X11R7/include +/usr/local/X11R6/include +/usr/local/X11R5/include +/usr/local/X11R4/include + +/usr/local/include/X11 +/usr/local/include/X11R7 +/usr/local/include/X11R6 +/usr/local/include/X11R5 +/usr/local/include/X11R4 + +/usr/X386/include +/usr/x386/include +/usr/XFree86/include/X11 + +/usr/include +/usr/local/include +/usr/unsupported/include +/usr/athena/include +/usr/local/x11r5/include +/usr/lpp/Xamples/include + +/usr/openwin/include +/usr/openwin/share/include' + +if test "$ac_x_includes" = no; then + # Guess where to find include files, by looking for Xlib.h. + # First, try using that file with no special directory specified. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # We can compile using X headers with no special include directory. +ac_x_includes= +else + for ac_dir in $ac_x_header_dirs; do + if test -r "$ac_dir/X11/Xlib.h"; then + ac_x_includes=$ac_dir + break + fi +done +fi +rm -f conftest.err conftest.i conftest.$ac_ext +fi # $ac_x_includes = no + +if test "$ac_x_libraries" = no; then + # Check for the libraries. + # See if we find them without any special options. + # Don't add to $LIBS permanently. + ac_save_LIBS=$LIBS + LIBS="-lX11 $LIBS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +XrmInitialize () + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + LIBS=$ac_save_LIBS +# We can link X programs with no special library path. +ac_x_libraries= +else + LIBS=$ac_save_LIBS +for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` +do + # Don't even attempt the hair of trying to link an X program! + for ac_extension in a so sl dylib la dll; do + if test -r "$ac_dir/libX11.$ac_extension"; then + ac_x_libraries=$ac_dir + break 2 + fi + done +done +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi # $ac_x_libraries = no + +case $ac_x_includes,$ac_x_libraries in #( + no,* | *,no | *\'*) + # Didn't find X, or a directory has "'" in its name. + ac_cv_have_x="have_x=no";; #( + *) + # Record where we found X for the cache. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$ac_x_includes'\ + ac_x_libraries='$ac_x_libraries'" +esac +fi +;; #( + *) have_x=yes;; + esac + eval "$ac_cv_have_x" +fi # $with_x != no + +if test "$have_x" != yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 +$as_echo "$have_x" >&6; } + no_x=yes +else + # If each of the values was on the command line, it overrides each guess. + test "x$x_includes" = xNONE && x_includes=$ac_x_includes + test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries + # Update the cache value to reflect the command line values. + ac_cv_have_x="have_x=yes\ + ac_x_includes='$x_includes'\ + ac_x_libraries='$x_libraries'" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 +$as_echo "libraries $x_libraries, headers $x_includes" >&6; } +fi + + + if test -n "$x_includes"; then + X_CFLAGS="$X_CFLAGS -I$x_includes" + fi + + if test -n "$x_libraries"; then + X_LIBS="$X_LIBS -L$x_libraries" + fi + + if test "x-$no_x" = "x-yes" ; then + + if test "x-$x11_hidd" != "x-auto" ; then + as_fn_error $? "X11 libs/headers not found, cannot build X11 hidd as requested" "$LINENO" 5 + fi + + else + aros_target_options+="$export_newline""# Enable X11 Gfx Driver$export_newline""OPT_HOST_X11GFX := yes$export_newline" + if test "x-$host_feature_glx" != "x-no" ; then + aros_target_options+="$export_newline""# Enable X11 HostGL 3D Passthrough$export_newline""OPT_HOST_X11_HOSTGL := yes$export_newline" + fi + ENABLE_X11=1 + + aros_host_x11_cflags="$X_CFLAGS" + aros_host_x11_ldflags="$X_LIBS -lX11" + + # Check whether --enable-x11_shm was given. +if test "${enable_x11_shm+set}" = set; then : + enableval=$enable_x11_shm; x11_hidd_shm="$enableval" +else + x11_hidd_shm="auto" +fi + + case "x-$x11_hidd_shm" in + x-yes|x-no|x-auto) ;; + *) x11_hidd_shm="auto" ;; + esac + + have_xshm=no + + if test "x-$x11_hidd_shm" != "x-no" ; then + + for ac_header in sys/ipc.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ipc_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_SYS_IPC_H 1 +_ACEOF + +fi + +done + + for ac_header in sys/shm.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_shm_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_SYS_SHM_H 1 +_ACEOF + +fi + +done + + + if test "x-$ac_cv_header_sys_ipc_h" = "x-yes" -a "x-$ac_cv_header_sys_shm_h" = "x-yes" ; then + + save_cflags="$CFLAGS" + save_ldflags="$LDFLAGS" + CFLAGS="$CFLAGS $X_CFLAGS" + LDFLAGS="$LDFLAGS $X_LIBS" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XShmQueryExtension in -lXext" >&5 +$as_echo_n "checking for XShmQueryExtension in -lXext... " >&6; } +if ${ac_cv_lib_Xext_XShmQueryExtension+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lXext $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char XShmQueryExtension (); +int +main () +{ +return XShmQueryExtension (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_Xext_XShmQueryExtension=yes +else + ac_cv_lib_Xext_XShmQueryExtension=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xext_XShmQueryExtension" >&5 +$as_echo "$ac_cv_lib_Xext_XShmQueryExtension" >&6; } +if test "x$ac_cv_lib_Xext_XShmQueryExtension" = xyes; then : + have_xshm=yes +fi + + CFLAGS="$save_cflags" + LDFLAGS="$save_ldflags" + fi + fi + + if test "x-$have_xshm" = "x-yes" ; then + DO_XSHM_SUPPORT="1" + elif test "x-$x11_hidd_shm" = "x-yes" ; then + as_fn_error $? "X11 has no support for shared memory, cannot enable it as requested" "$LINENO" 5 + else + DO_XSHM_SUPPORT="0" + fi + + + # Check whether --enable-x11_vidmode was given. +if test "${enable_x11_vidmode+set}" = set; then : + enableval=$enable_x11_vidmode; x11_hidd_vidmode="$enableval" +else + x11_hidd_vidmode="auto" +fi + + case "x-$x11_hidd_vidmode" in + x-yes|x-no|x-auto) ;; + *) x11_hidd_vidmode="auto" ;; + esac + + have_vidmode=no + + if test "x-$x11_hidd_vidmode" != "x-no" ; then + + save_cflags="$CFLAGS" + save_ldflags="$LDFLAGS" + CFLAGS="$CFLAGS $X_CFLAGS" + LDFLAGS="$LDFLAGS $X_LIBS" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryExtension in -lXxf86vm" >&5 +$as_echo_n "checking for XF86VidModeQueryExtension in -lXxf86vm... " >&6; } +if ${ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lXxf86vm $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char XF86VidModeQueryExtension (); +int +main () +{ +return XF86VidModeQueryExtension (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=yes +else + ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&5 +$as_echo "$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&6; } +if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" = xyes; then : + have_vidmode=yes +fi + + CFLAGS="$save_cflags" + LDFLAGS="$save_ldflags" + fi + + if test "x-$have_vidmode" = "x-yes" ; then + DO_VIDMODE_SUPPORT="1" + elif test "x-$x11_hidd_vidmode" = "x-yes" ; then + as_fn_error $? "X11 vidmode extension not available, cannot enable it as requested" "$LINENO" 5 + else + DO_VIDMODE_SUPPORT="0" + fi + fi + fi + + # Check whether --enable-sdl_hidd was given. +if test "${enable_sdl_hidd+set}" = set; then : + enableval=$enable_sdl_hidd; sdl_hidd="$enableval" +else + sdl_hidd="auto" +fi + + case "x-$sdl_hidd" in + x-yes|x-no|x-auto) ;; + *) sdl_hidd="auto" ;; + esac + + if test "x-$sdl_hidd" != "x-no" ; then + + SDL_VERSION=1.2.5 + +# Check whether --with-sdl-prefix was given. +if test "${with_sdl_prefix+set}" = set; then : + withval=$with_sdl_prefix; sdl_prefix="$withval" +else + sdl_prefix="" +fi + + +# Check whether --with-sdl-exec-prefix was given. +if test "${with_sdl_exec_prefix+set}" = set; then : + withval=$with_sdl_exec_prefix; sdl_exec_prefix="$withval" +else + sdl_exec_prefix="" +fi + +# Check whether --enable-sdltest was given. +if test "${enable_sdltest+set}" = set; then : + enableval=$enable_sdltest; +else + enable_sdltest=yes +fi + + + if test x$sdl_exec_prefix != x ; then + sdl_config_args="$sdl_config_args --exec-prefix=$sdl_exec_prefix" + if test x${SDL_CONFIG+set} != xset ; then + SDL_CONFIG=$sdl_exec_prefix/bin/sdl-config + fi + fi + if test x$sdl_prefix != x ; then + sdl_config_args="$sdl_config_args --prefix=$sdl_prefix" + if test x${SDL_CONFIG+set} != xset ; then + SDL_CONFIG=$sdl_prefix/bin/sdl-config + fi + fi + + as_save_PATH="$PATH" + if test "x$prefix" != xNONE; then + PATH="$prefix/bin:$prefix/usr/bin:$PATH" + fi + # Extract the first word of "sdl-config", so it can be a program name with args. +set dummy sdl-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_path_SDL_CONFIG+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $SDL_CONFIG in + [\\/]* | ?:[\\/]*) + ac_cv_path_SDL_CONFIG="$SDL_CONFIG" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + 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_SDL_CONFIG="$as_dir/$ac_word$ac_exec_ext" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_path_SDL_CONFIG" && ac_cv_path_SDL_CONFIG="no" + ;; +esac +fi +SDL_CONFIG=$ac_cv_path_SDL_CONFIG +if test -n "$SDL_CONFIG"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5 +$as_echo "$SDL_CONFIG" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + PATH="$as_save_PATH" + min_sdl_version=$SDL_VERSION + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SDL - version >= $min_sdl_version" >&5 +$as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; } + no_sdl="" + if test "$SDL_CONFIG" = "no" ; then + no_sdl=yes + else + SDL_CFLAGS=`$SDL_CONFIG $sdl_config_args --cflags` + SDL_LIBS=`$SDL_CONFIG $sdl_config_args --libs` + + sdl_major_version=`$SDL_CONFIG $sdl_config_args --version | \ + sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\1/'` + sdl_minor_version=`$SDL_CONFIG $sdl_config_args --version | \ + sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\2/'` + sdl_micro_version=`$SDL_CONFIG $sdl_config_args --version | \ + sed 's/\([0-9]*\).\([0-9]*\).\([0-9]*\)/\3/'` + if test "x$enable_sdltest" = "xyes" ; then + ac_save_CFLAGS="$CFLAGS" + ac_save_CXXFLAGS="$CXXFLAGS" + ac_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $SDL_CFLAGS" + CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" + LIBS="$LIBS $SDL_LIBS" + rm -f conf.sdltest + if test "$cross_compiling" = yes; then : + echo $ac_n "cross compiling; assumed OK... $ac_c" +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +#include +#include +#include +#include "SDL.h" + +char* +my_strdup (char *str) +{ + char *new_str; + + if (str) + { + new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char)); + strcpy (new_str, str); + } + else + new_str = NULL; + + return new_str; +} + +int main (int argc, char *argv[]) +{ + int major, minor, micro; + char *tmp_version; + + /* This hangs on some systems (?) + system ("touch conf.sdltest"); + */ + { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); } + + /* HP/UX 9 (%@#!) writes to sscanf strings */ + tmp_version = my_strdup("$min_sdl_version"); + if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) { + printf("%s, bad version string\n", "$min_sdl_version"); + exit(1); + } + + if (($sdl_major_version > major) || + (($sdl_major_version == major) && ($sdl_minor_version > minor)) || + (($sdl_major_version == major) && ($sdl_minor_version == minor) && ($sdl_micro_version >= micro))) + { + return 0; + } + else + { + printf("\n*** 'sdl-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version); + printf("*** of SDL required is %d.%d.%d. If sdl-config is correct, then it is\n", major, minor, micro); + printf("*** best to upgrade to the required version.\n"); + printf("*** If sdl-config was wrong, set the environment variable SDL_CONFIG\n"); + printf("*** to point to the correct copy of sdl-config, and remove the file\n"); + printf("*** config.cache before re-running configure\n"); + return 1; + } +} + + +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + no_sdl=yes +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + + CFLAGS="$ac_save_CFLAGS" + CXXFLAGS="$ac_save_CXXFLAGS" + LIBS="$ac_save_LIBS" + fi + fi + if test "x$no_sdl" = x ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + have_sdl="yes" + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + if test "$SDL_CONFIG" = "no" ; then + echo "*** The sdl-config script installed by SDL could not be found" + echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in" + echo "*** your path, or set the SDL_CONFIG environment variable to the" + echo "*** full path to sdl-config." + else + if test -f conf.sdltest ; then + : + else + echo "*** Could not run SDL test program, checking why..." + CFLAGS="$CFLAGS $SDL_CFLAGS" + CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" + LIBS="$LIBS $SDL_LIBS" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +#include +#include "SDL.h" + +int main(int argc, char *argv[]) +{ return 0; } +#undef main +#define main K_and_R_C_main + +int +main () +{ + return 0; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + echo "*** The test program compiled, but did not run. This usually means" + echo "*** that the run-time linker is not finding SDL or finding the wrong" + echo "*** version of SDL. If it is not finding SDL, you'll need to set your" + echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" + echo "*** to the installed location Also, make sure you have run ldconfig if that" + echo "*** is required on your system" + echo "***" + echo "*** If you have an old version installed, it is best to remove it, although" + echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" +else + echo "*** The test program failed to compile or link. See the file config.log for the" + echo "*** exact error that occured. This usually means SDL was incorrectly installed" + echo "*** or that you have moved SDL since it was installed. In the latter case, you" + echo "*** may want to edit the sdl-config script: $SDL_CONFIG" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + CFLAGS="$ac_save_CFLAGS" + CXXFLAGS="$ac_save_CXXFLAGS" + LIBS="$ac_save_LIBS" + fi + fi + SDL_CFLAGS="" + SDL_LIBS="" + have_sdl="no" + fi + + + rm -f conf.sdltest + + + if test "x-$have_sdl" != "x-yes" ; then + + if test "x-$sdl_hidd" != "x-auto" ; then + as_fn_error $? "SDL libs/headers not found, cannot build SDL hidd as requested" "$LINENO" 5 + fi + + else + aros_target_options+="$export_newline""# Enable SDL Gfx Driver$export_newline""OPT_HOST_SDLGFX := yes$export_newline" + aros_host_sdl_cflags=$SDL_CFLAGS + aros_host_sdl_libs=$SDL_LIBS + fi + fi + +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether building of dbus.library is enabled" >&5 +$as_echo_n "checking whether building of dbus.library is enabled... " >&6; } +# Check whether --enable-dbus was given. +if test "${enable_dbus+set}" = set; then : + enableval=$enable_dbus; dbus="yes" +else + dbus="no" +fi + +if test "$dbus" = "yes" ; then + ENABLE_DBUS=1 + DBUS_CFLAGS=`pkg-config --cflags dbus-1` + DBUS_LIBFLAGS=`pkg-config --libs dbus-1` + KERNEL_DBUS_KOBJ=kernel-dbus-kobj + KERNEL_DBUS_INCLUDES=kernel-dbus-includes +else + ENABLE_DBUS=0 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dbus" >&5 +$as_echo "$dbus" >&6; } + +if test "$use_kernel_cc_wrapper" = "yes" ; then + aros_kernel_cc="${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-${toolchain_c_compiler}" +fi + +aros_kernel_cppflags=$aros_config_cppflags +aros_optimization_cflags="$optimization_level" +if test "$optimization" = "default"; then +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking default optimization level to use" >&5 +$as_echo_n "checking default optimization level to use... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization_level" >&5 +$as_echo "$optimization_level" >&6; } +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking kernel optimization level to conserve space" >&5 +$as_echo_n "checking kernel optimization level to conserve space... " >&6; } +if test "$kernel_optimization_level" = ""; then + kernel_optimization_level=$optimization_level +fi +kernel_optimization_cflags="$kernel_optimization_level" +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_optimization_level" >&5 +$as_echo "$kernel_optimization_level" >&6; } + +if ! test "$gcc_default_cpu" = "" ; then + target_extra_cfg+="$export_newline""# ARM gcc default target$export_newline""GCC_DEFAULT_CPU := $gcc_default_cpu$export_newline""GCC_DEFAULT_FPU := $gcc_default_fpu$export_newline""GCC_DEFAULT_FLOAT_ABI := $gcc_default_float_abi$export_newline""GCC_DEFAULT_MODE := $gcc_default_mode$export_newline" +fi + +if test "$use_libatomic" = "yes" ; then + aros_cxx_libs="$aros_cxx_libs -latomic" +fi + +aros_target_options+="$export_newline""# Enable Nouveau Gfx Driver$export_newline""OPT_GFX_NOUVEAU := no$export_newline" + + +CC=$CC +CFLAGS=$CFLAGS +CHMOD=$CHMOD +CP=$CP +ECHO=$ECHO +FLEX=$FLEX +MV=$MV +NOP=$NOP +PATCH=$PATCH +PNGTOPNM=$PNGTOPNM +PPMTOILBM=$PPMTOILBM +SED=$SED +SORT=$SORT +TOUCH=$TOUCH +UNIQ=$UNIQ + +aros_config_cflags=$aros_config_cflags +aros_config_cppflags=$aros_config_cppflags +aros_config_cxxflags=$aros_config_cxxflags + +aros_c_libs=$aros_c_libs +aros_cxx_libs=$aros_cxx_libs + +aros_host_ldflags=$aros_host_ldflags +aros_host_strip=$aros_host_strip +aros_host_x11_ldflags=$aros_host_x11_ldflags + +aros_kernel_ar=$aros_kernel_ar +aros_kernel_as=$aros_kernel_as +aros_kernel_cc=$aros_kernel_cc +aros_kernel_cflags=$aros_kernel_cflags +aros_kernel_cppflags=$aros_kernel_cppflags +aros_kernel_cxx=$aros_kernel_cxx +aros_kernel_nm=$aros_kernel_nm +aros_kernel_objcopy=$aros_kernel_objcopy +aros_kernel_objdump=$aros_kernel_objdump +aros_kernel_ranlib=$aros_kernel_ranlib + +# Generic + + + + + + + + + + + + + + +# Compatability with other Amiga-like operating systems + + +# Host Related ########################### + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# Target Related ######################### + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# Distro specific stuff + + + + + +# Native version related + + + + +# MMU related + + +# Bootloader related + + +# Unix/Hosted version related + + +# ARM default GCC target related + + + + + + +# Palm native version related + + +# Apple iOS related + + + + +# Android related + + + + + +# Debug related + + + + + +# Collect-aros stuff: "-ius" to ignore undefined symbols + + +# C compiler related + + + + + +#ObjC compiler related + + +#Java related + + +# DBUS related + + + + + + +#X11 related + + + + + + + +#SDL related + + + +# USB3.0 code + + +# The preference set option(s).. + + +case "$aros_flavour" in +emulation) aros_flavour_uc="AROS_FLAVOUR_EMULATION" + aros_flavour="emulation" ;; +emulcompat) aros_flavour_uc="(AROS_FLAVOUR_EMULATION|AROS_FLAVOUR_BINCOMPAT)" + aros_flavour="emulation" ;; +standalone) aros_flavour_uc="AROS_FLAVOUR_STANDALONE" + aros_flavour="standalone";; +standcompat) aros_flavour_uc="(AROS_FLAVOUR_STANDALONE|AROS_FLAVOUR_BINCOMPAT)" + aros_flavour="standalone";; +native) aros_flavour_uc="AROS_FLAVOUR_NATIVE" + aros_flavour="native" ;; +nativecompat) aros_flavour_uc="(AROS_FLAVOUR_NATIVE|AROS_FLAVOUR_BINCOMPAT)" + aros_flavour="native" ;; +linklib) aros_flavour_uc="AROS_FLAVOUR_LINKLIB" + aros_flavour="linklib" ;; +palmnative) aros_flavour_uc="(AROS_FLAVOUR_STANDALONE|AROS_FLAVOUR_EMULATION)" + aros_flavour="palmnative" ;; +mac68knative) aros_flavour_uc="(AROS_FLAVOUR_STANDALONE|AROS_FLAVOUR_EMULATION)" + aros_flavour="mac68knative" ;; +ppcnative) aros_flavour_uc="(AROS_FLAVOUR_STANDALONE|AROS_FLAVOUR_BINCOMPAT)" + aros_flavour="ppcnative" ;; +esac + +if test ! -d ${aros_inc_dir} ; then + ${MKDIR} ${aros_inc_dir} +fi +if test ! -d ${aros_geninc_dir} ; then + ${MKDIR} ${aros_geninc_dir} +fi +if test ! -d ${aros_hostcfg_dir} ; then + ${MKDIR} ${aros_hostcfg_dir} +fi +if test ! -d ${aros_targetcfg_dir} ; then + ${MKDIR} ${aros_targetcfg_dir} +fi +if test ! -d ${aros_tools_dir} ; then + ${MKDIR} ${aros_tools_dir} +fi +if test ! -d ${aros_scripts_dir} ; then + ${MKDIR} ${aros_scripts_dir} +fi + +ac_config_headers="$ac_config_headers ${aros_geninc_dir}/host-conf.h:config/host-conf.h.in" + + +# Generic build tools (metamake, etc) +ac_config_commands="$ac_config_commands genmf-executable-support" + +ac_config_files="$ac_config_files Makefile config/make.cfg ${aros_inc_dir}/config.h:config/config.h.in ${aros_geninc_dir}/config.h:config/config.h.in ${aros_hostcfg_dir}/host.cfg:config/host.cfg.in ${aros_targetcfg_dir}/target.cfg:config/target.cfg.in ${aros_targetcfg_dir}/build.cfg:config/build.cfg.in mmake.config compiler/include/geninc.cfg:compiler/include/geninc.cfg.in ${aros_targetcfg_dir}/make.defaults:config/make.defaults.in ${aros_tools_dir}/genmf.py:tools/genmf/genmf.py ${AROS_CROSSTOOLSDIR}/${aros_target_cpu}-aros-uname:scripts/uname.in tools/collect-aros/env.h" + + +# Binutils +ac_config_commands="$ac_config_commands binutils-support" + +if test "${use_ld_wrapper}" = "yes"; then + ac_config_files="$ac_config_files ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${aros_ld}:scripts/aros-ld.in" + +fi +# Bare Elf support script and spec +if test "${use_kernel_cc_wrapper}" = "yes"; then + ac_config_commands="$ac_config_commands elf-compiler-support" + + ac_config_files="$ac_config_files ${aros_targetcfg_dir}/elf-specs:${elf_specs_in} ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-gcc:scripts/elf-gcc.in" + +fi + +# Host compiler support scripts and spec +if test "${aros_target_toolchain}" = "no"; then + ac_config_commands="$ac_config_commands host-compiler-wrapper-support" + + ac_config_files="$ac_config_files ${aros_targetcfg_dir}/specs:config/specs.in ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cpp_preprocessor}:scripts/aros-${toolchain_cpp_preprocessor}.in ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_c_compiler}:scripts/aros-${toolchain_c_compiler}.in ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cxx_compiler}:scripts/aros-${toolchain_cxx_compiler}.in" + +fi + +# Android support +if test "$aros_target_variant" == "android"; then + ac_config_files="$ac_config_files ${aros_gendir}/arch/all-android/bootstrap/app/default.properties:arch/all-android/bootstrap/app/default.properties.in" + +fi + +# cmake helper +ac_config_files="$ac_config_files ${aros_targetcfg_dir}/conf.cmake:config/conf.cmake.in" + + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_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_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$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 +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +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 + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; 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=`$as_echo "$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" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +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 + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +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 + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || 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 $as_me, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +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" +config_commands="$ac_config_commands" + +_ACEOF + +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 +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to the package provider." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +config.status +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +test -n "\$AWK" || AWK=awk +_ACEOF + +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 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +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 + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +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 + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# + + AROS_CROSSTOOLSDIR=${AROS_CROSSTOOLSDIR} + aros_tools_dir=${aros_tools_dir} + + + + aros_host_exe_suffix=${aros_host_exe_suffix} + aros_tools_dir=${aros_tools_dir} + aros_target_cpu=${aros_target_cpu} + aros_target_arch=${aros_target_arch} + aros_target_suffix=${aros_target_suffix} + orig_target_nm=${orig_target_nm} + orig_target_as=${orig_target_as} + orig_target_ar=${orig_target_ar} + orig_target_ranlib=${orig_target_ranlib} + orig_target_objdump=${orig_target_objdump} + orig_target_objcopy=${orig_target_objcopy} + orig_target_strip=${orig_target_strip} + aros_kernel_ld=${aros_kernel_ld} + + + + aros_host_exe_suffix=${aros_host_exe_suffix} + aros_tools_dir=${aros_tools_dir} + aros_target_cpu=${aros_target_cpu} + aros_target_arch=${aros_target_arch} + aros_target_suffix=${aros_target_suffix} + aros_kernel_ld=${aros_kernel_ld} + + + + aros_host_exe_suffix=${aros_host_exe_suffix} + aros_tools_dir=${aros_tools_dir} + aros_target_cpu=${aros_target_cpu} + aros_target_arch=${aros_target_arch} + aros_target_suffix=${aros_target_suffix} + + + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "${aros_geninc_dir}/host-conf.h") CONFIG_HEADERS="$CONFIG_HEADERS ${aros_geninc_dir}/host-conf.h:config/host-conf.h.in" ;; + "genmf-executable-support") CONFIG_COMMANDS="$CONFIG_COMMANDS genmf-executable-support" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "config/make.cfg") CONFIG_FILES="$CONFIG_FILES config/make.cfg" ;; + "${aros_inc_dir}/config.h") CONFIG_FILES="$CONFIG_FILES ${aros_inc_dir}/config.h:config/config.h.in" ;; + "${aros_geninc_dir}/config.h") CONFIG_FILES="$CONFIG_FILES ${aros_geninc_dir}/config.h:config/config.h.in" ;; + "${aros_hostcfg_dir}/host.cfg") CONFIG_FILES="$CONFIG_FILES ${aros_hostcfg_dir}/host.cfg:config/host.cfg.in" ;; + "${aros_targetcfg_dir}/target.cfg") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/target.cfg:config/target.cfg.in" ;; + "${aros_targetcfg_dir}/build.cfg") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/build.cfg:config/build.cfg.in" ;; + "mmake.config") CONFIG_FILES="$CONFIG_FILES mmake.config" ;; + "compiler/include/geninc.cfg") CONFIG_FILES="$CONFIG_FILES compiler/include/geninc.cfg:compiler/include/geninc.cfg.in" ;; + "${aros_targetcfg_dir}/make.defaults") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/make.defaults:config/make.defaults.in" ;; + "${aros_tools_dir}/genmf.py") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/genmf.py:tools/genmf/genmf.py" ;; + "${AROS_CROSSTOOLSDIR}/${aros_target_cpu}-aros-uname") CONFIG_FILES="$CONFIG_FILES ${AROS_CROSSTOOLSDIR}/${aros_target_cpu}-aros-uname:scripts/uname.in" ;; + "tools/collect-aros/env.h") CONFIG_FILES="$CONFIG_FILES tools/collect-aros/env.h" ;; + "binutils-support") CONFIG_COMMANDS="$CONFIG_COMMANDS binutils-support" ;; + "${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${aros_ld}") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${aros_ld}:scripts/aros-ld.in" ;; + "elf-compiler-support") CONFIG_COMMANDS="$CONFIG_COMMANDS elf-compiler-support" ;; + "${aros_targetcfg_dir}/elf-specs") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/elf-specs:${elf_specs_in}" ;; + "${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-gcc") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-gcc:scripts/elf-gcc.in" ;; + "host-compiler-wrapper-support") CONFIG_COMMANDS="$CONFIG_COMMANDS host-compiler-wrapper-support" ;; + "${aros_targetcfg_dir}/specs") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/specs:config/specs.in" ;; + "${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cpp_preprocessor}") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cpp_preprocessor}:scripts/aros-${toolchain_cpp_preprocessor}.in" ;; + "${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_c_compiler}") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_c_compiler}:scripts/aros-${toolchain_c_compiler}.in" ;; + "${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cxx_compiler}") CONFIG_FILES="$CONFIG_FILES ${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros-${toolchain_cxx_compiler}:scripts/aros-${toolchain_cxx_compiler}.in" ;; + "${aros_gendir}/arch/all-android/bootstrap/app/default.properties") CONFIG_FILES="$CONFIG_FILES ${aros_gendir}/arch/all-android/bootstrap/app/default.properties:arch/all-android/bootstrap/app/default.properties.in" ;; + "${aros_targetcfg_dir}/conf.cmake") CONFIG_FILES="$CONFIG_FILES ${aros_targetcfg_dir}/conf.cmake:config/conf.cmake.in" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + 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='%!_!# ' +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` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +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 + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + 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=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$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/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + +_ACEOF + +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= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_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 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +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 +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +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"; } && + { $as_echo "$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 +$as_echo "$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" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && 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 + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$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 + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "genmf-executable-support":C) + chmod a+x ${AROS_CROSSTOOLSDIR}/${aros_target_cpu}-aros-uname + chmod a+x ${aros_tools_dir}/genmf.py + ;; + "binutils-support":C) + prefix=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix} + mkdir -p $prefix + prefix2=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros + + chmod a+x ${prefix2}-ld + + ln -sf $orig_target_as$aros_host_exe_suffix ${prefix2}-as$aros_host_exe_suffix + ln -sf $orig_target_nm$aros_host_exe_suffix ${prefix2}-nm$aros_host_exe_suffix + ln -sf $orig_target_ar$aros_host_exe_suffix ${prefix2}-ar$aros_host_exe_suffix + ln -sf $orig_target_ranlib$aros_host_exe_suffix ${prefix2}-ranlib$aros_host_exe_suffix + ln -sf $orig_target_objcopy$aros_host_exe_suffix ${prefix2}-objcopy$aros_host_exe_suffix + ln -sf $orig_target_objdump$aros_host_exe_suffix ${prefix2}-objdump$aros_host_exe_suffix + ln -sf $orig_target_strip$aros_host_exe_suffix ${prefix2}-strip$aros_host_exe_suffix + ;; + "elf-compiler-support":C) + prefix=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix} + mkdir -p $prefix + prefix2=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf + + chmod a+x ${prefix2}-gcc + + ln -sf $aros_kernel_ld$aros_host_exe_suffix ${prefix2}-ld$aros_host_exe_suffix + ;; + "host-compiler-wrapper-support":C) + prefix=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix} + mkdir -p $prefix + prefix2=${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-aros + + chmod a+x ${prefix2}-${toolchain_c_compiler} ${prefix2}-${toolchain_cxx_compiler} ${prefix2}-${toolchain_cpp_preprocessor} + ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + 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 + 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. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + + + +#XXX compatability... +aros_shared_ar="$aros_shared_ld $aros_shared_ldflags -o" + +if test -n "$aros_shared_cflags" ; then + echo "SHARED_CFLAGS := $aros_shared_cflags" >> ${aros_hostcfg_dir}/host.cfg + echo "SHARED_AR := $aros_shared_ar" >> ${aros_hostcfg_dir}/host.cfg +fi + From 101cd9bfa2382b8e2c2cbf265a572ecfc546b731 Mon Sep 17 00:00:00 2001 From: WDrijver Date: Fri, 27 Dec 2024 17:34:02 +0100 Subject: [PATCH 4/5] ApolloROM R9.5-RC2 --- .gitignore | 3 + arch/m68k-amiga/boot/mmakefile.src | 54 +- config/make.cfg.in | 5 +- configure | 10 +- configure.in | 9 +- configure~ | 10689 +++++++++++++++------------ distname | 2 +- rebuild_all.sh | 11 +- rebuild_rom.sh | 16 +- rebuild_rom_with_debug.sh | 2 +- version | 2 +- 11 files changed, 6111 insertions(+), 4692 deletions(-) diff --git a/.gitignore b/.gitignore index 0b740689d61..5f3981183cc 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,9 @@ /autom4te.cache /.vscode +# Apollo +/ApolloROM.* + # /boot/ /boot/mmakefile diff --git a/arch/m68k-amiga/boot/mmakefile.src b/arch/m68k-amiga/boot/mmakefile.src index d66091aa1fc..c251635be0e 100644 --- a/arch/m68k-amiga/boot/mmakefile.src +++ b/arch/m68k-amiga/boot/mmakefile.src @@ -125,12 +125,25 @@ ROMLOC_rom := 0x0f80000 FILES=start early debug mmu AFILES=rom_entry rom_init cpu_detect superstack_swap -KLIBS := exec aros dos utility oop expansion partition debug -KDEVS := timer input keyboard console gameport audio -KHNDLRS := con afs ram -KHIDDS := amigakbd amigamouse amigavideo ata_gayle gfx hiddclass keyboard mouse -KRSRCS := battclock kernel processor task lddemon dosboot cia potgo disk FileSystem misc shell card bootloader vampire -KHOOKS := diag romboot +# APOLLOROM = V4 -> Native V4 +ifeq ($(APOLLOROM),V4) + KLIBS := exec aros dos utility oop expansion partition debug + KDEVS := timer input keyboard console gameport audio + KHNDLRS := con afs ram + KHIDDS := amigakbd amigamouse amigavideo ata_gayle gfx hiddclass keyboard mouse + KRSRCS := battclock kernel processor task lddemon dosboot cia potgo disk FileSystem misc shell card bootloader vampire + KHOOKS := diag romboot +endif + +# APOLLOROM = UAE -> UAE with P96 +ifeq ($(APOLLOROM),UAE) + KLIBS := exec aros dos utility oop expansion partition + KDEVS := timer input keyboard console gameport audio + KHNDLRS := con afs ram + KHIDDS := amigakbd amigamouse amigavideo ata_gayle gfx hiddclass keyboard mouse p96gfx + KRSRCS := battclock kernel processor task lddemon dosboot cia potgo disk FileSystem + KHOOKS := +endif KOBJS_rom := $(addprefix $(KOBJSDIR)/,$(addsuffix _library.ko ,$(KLIBS))) \ $(addprefix $(KOBJSDIR)/,$(addsuffix _device.ko ,$(KDEVS))) \ @@ -149,14 +162,25 @@ $(GENDIR)/boot/aros-amiga-m68k-rom.elf: $(KOBJS_rom) $(OBJS_rom) FILES := AFILES := ext_entry -KLIBS := keymap graphics layers intuition gadtools workbench \ - mathffp mathieeesingbas freeanim lowlevel \ - setpatch -KDEVS := cd ata trackdisk -KHNDLRS := cdrom -KHIDDS := bus storage system -KRSRCS := shellcommands wbtag -KHOOKS := alert +# APOLLOROM = V4 -> Native V4 +ifeq ($(APOLLOROM),V4) + KLIBS := keymap graphics layers intuition gadtools workbench mathffp mathieeesingbas freeanim lowlevel setpatch + KDEVS := cd ata trackdisk + KHNDLRS := cdrom + KHIDDS := bus storage system + KRSRCS := shellcommands wbtag + KHOOKS := alert +endif + +# APOLLOROM = UAE -> UAE with P96 +ifeq ($(APOLLOROM),UAE) + KLIBS := keymap graphics layers intuition gadtools workbench mathffp mathieeesingbas freeanim lowlevel setpatch + KDEVS := cd ata trackdisk + KHNDLRS := cdrom + KHIDDS := bus storage system + KRSRCS := shellcommands wbtag misc shell card bootloader + KHOOKS := alert diag romboot +endif ROMLOC_ext := 0xe00000 KOBJS_ext := \ @@ -380,4 +404,4 @@ $(AROSARCHDIR)/aros.elf.dbg : $(DEPLIBS) $(SRCDIR)/$(CURDIR)/mmakefile.src \ fi -%common +%common \ No newline at end of file diff --git a/config/make.cfg.in b/config/make.cfg.in index 8e20b64bbf5..2d4952d554a 100644 --- a/config/make.cfg.in +++ b/config/make.cfg.in @@ -1,4 +1,4 @@ -# Copyright © 1995-2020, The AROS Development Team. All rights reserved. +# Copyright � 1995-2020, The AROS Development Team. All rights reserved. # $Id$ # # Static makefile rule file for AROS. @@ -302,3 +302,6 @@ WILDCARD = $(shell cd $(SRCDIR)/$(CURDIR); for file in $(1) # Defined to quieten output.. Q ?= @ + +#Apollo Make Variables +APOLLOROM := @apollorom_target@ \ No newline at end of file diff --git a/configure b/configure index a60057e36f3..2cc759b71f7 100755 --- a/configure +++ b/configure @@ -726,6 +726,7 @@ aros_config_cflags aros_config_cppflags aros_nowarn_flags aros_warn_flags +apollorom_target aros_shared_ldflags aros_shared_aflags aros_shared_cflags @@ -8904,6 +8905,8 @@ fi printf "%s\n" "$as_me: Performing target configuration..." >&6;} +apollorom_target= + test_kernel_cc=no aros_nowarn_flags="NOWARN_UNUSED_COMMAND_LINE_ARGUMENT NOWARN_UNKNOWN_WARNING_OPTION NOWARN_POINTER_SIGN NOWARN_PARENTHESES" @@ -16623,9 +16626,11 @@ printf "%s\n" "Enabling nonvampire support" >&6; } aros_config_cflags="$aros_config_cflags -DNONVAMPIRE" aros_kernel_cppflags="$aros_kernel_cppflags -DNONVAMPIRE" aros_kernel_cflags="$aros_kernel_cflags -DNONVAMPIRE" + apollorom_target="UAE" else { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } + apollorom_target="V4" fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 @@ -17634,6 +17639,8 @@ SORT=$SORT TOUCH=$TOUCH UNIQ=$UNIQ +apollorom_target=$apollorom_target + aros_config_cflags=$aros_config_cflags aros_config_cppflags=$aros_config_cppflags aros_config_cxxflags=$aros_config_cxxflags @@ -17800,6 +17807,8 @@ aros_kernel_ranlib=$aros_kernel_ranlib + + @@ -19364,4 +19373,3 @@ if test -n "$aros_shared_cflags" ; then echo "SHARED_AR := $aros_shared_ar" >> ${aros_hostcfg_dir}/host.cfg fi - diff --git a/configure.in b/configure.in index f3d13694d4a..efe2ee2076a 100644 --- a/configure.in +++ b/configure.in @@ -762,6 +762,8 @@ dnl The target configuration section is responsible for setting up all dnl the paths for includes, and tools required to build AROS to some dnl particular target. +apollorom_target= + test_kernel_cc=no aros_nowarn_flags="NOWARN_UNUSED_COMMAND_LINE_ARGUMENT NOWARN_UNKNOWN_WARNING_OPTION NOWARN_POINTER_SIGN NOWARN_PARENTHESES" @@ -3009,8 +3011,10 @@ if test "$nonvampire_support" = "yes"; then aros_config_cflags="$aros_config_cflags -DNONVAMPIRE" aros_kernel_cppflags="$aros_kernel_cppflags -DNONVAMPIRE" aros_kernel_cflags="$aros_kernel_cflags -DNONVAMPIRE" + apollorom_target="UAE" else AC_MSG_RESULT(no) + apollorom_target="V4" fi dnl check to see if we are enabling support for the V2 @@ -3351,6 +3355,8 @@ SORT=m4_normalize($SORT) TOUCH=m4_normalize($TOUCH) UNIQ=m4_normalize($UNIQ) +apollorom_target=m4_normalize($apollorom_target) + aros_config_cflags=m4_normalize($aros_config_cflags) aros_config_cppflags=m4_normalize($aros_config_cppflags) aros_config_cxxflags=m4_normalize($aros_config_cxxflags) @@ -3480,6 +3486,8 @@ AC_SUBST(aros_shared_cflags) AC_SUBST(aros_shared_aflags) AC_SUBST(aros_shared_ldflags) +AC_SUBST(apollorom_target) + AC_SUBST(aros_warn_flags) AC_SUBST(aros_nowarn_flags) AC_SUBST(aros_config_cppflags) @@ -3790,4 +3798,3 @@ if test -n "$aros_shared_cflags" ; then echo "SHARED_CFLAGS := $aros_shared_cflags" >> ${aros_hostcfg_dir}/host.cfg echo "SHARED_AR := $aros_shared_ar" >> ${aros_hostcfg_dir}/host.cfg fi - diff --git a/configure~ b/configure~ index f257323fdd9..a60057e36f3 100755 --- a/configure~ +++ b/configure~ @@ -1,9 +1,10 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69. +# Generated by GNU Autoconf 2.71. # # -# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation, +# Inc. # # # This configure script is free software; the Free Software Foundation @@ -14,14 +15,16 @@ # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : +as_nop=: +if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else +else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( @@ -31,46 +34,46 @@ esac fi + +# Reset variables that may have inherited troublesome values from +# the environment. + +# IFS needs to be set, to space, tab, and newline, in precisely that order. +# (If _AS_PATH_WALK were called with IFS unset, it would have the +# side effect of setting IFS to empty, thus disabling word splitting.) +# Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi +IFS=" "" $as_nl" + +PS1='$ ' +PS2='> ' +PS4='+ ' + +# Ensure predictable behavior from utilities with locale-dependent output. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# We cannot yet rely on "unset" to work, but we need these variables +# to be unset--not just set to an empty or harmless value--now, to +# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct +# also avoids known problems related to "unset" and subshell syntax +# in other old shells (e.g. bash 2.01 and pdksh 5.2.14). +for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH +do eval test \${$as_var+y} \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done + +# Ensure that fds 0, 1, and 2 are open. +if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi +if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then +if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || @@ -79,13 +82,6 @@ if test "${PATH_SEPARATOR+set}" != set; then fi -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( @@ -94,8 +90,12 @@ case $0 in #(( for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS @@ -107,30 +107,10 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - $as_echo "$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 -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. @@ -152,20 +132,22 @@ esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. -$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 -as_fn_exit 255 +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. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then - as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + as_bourne_compatible="as_nop=: +if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST -else +else \$as_nop case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( @@ -185,42 +167,53 @@ as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } -if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : +if ( set x; as_fn_ret_success y && test x = \"\$1\" ) +then : -else +else \$as_nop exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 +blah=\$(echo \$(echo blah)) +test x\"\$blah\" = xblah || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" - if (eval "$as_required") 2>/dev/null; then : + if (eval "$as_required") 2>/dev/null +then : as_have_required=yes -else +else $as_nop as_have_required=no fi - if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null +then : -else +else $as_nop as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. - as_shell=$as_dir/$as_base + as_shell=$as_dir$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null +then : CONFIG_SHELL=$as_shell as_have_required=yes - if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null +then : break 2 fi fi @@ -228,14 +221,21 @@ fi esac as_found=false done -$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && - { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : - CONFIG_SHELL=$SHELL as_have_required=yes -fi; } IFS=$as_save_IFS +if $as_found +then : + +else $as_nop + if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null +then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi +fi - if test "x$CONFIG_SHELL" != x; then : + if test "x$CONFIG_SHELL" != x +then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also @@ -253,18 +253,19 @@ esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. -$as_echo "$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 : - $as_echo "$0: This script requires a shell more modern than all" - $as_echo "$0: the shells that I found on your system." - if test x${ZSH_VERSION+set} = xset ; then - $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" - $as_echo "$0: be upgraded to zsh 4.3.4 or later." + 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." + 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." else - $as_echo "$0: Please tell bug-autoconf@gnu.org about your system, + printf "%s\n" "$0: Please tell bug-autoconf@gnu.org about your system, $0: including any error possibly output before this $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." @@ -291,6 +292,7 @@ as_fn_unset () } as_unset=as_fn_unset + # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. @@ -308,6 +310,14 @@ as_fn_exit () as_fn_set_status $1 exit $1 } # as_fn_exit +# as_fn_nop +# --------- +# Do nothing but, unlike ":", preserve the value of $?. +as_fn_nop () +{ + return $? +} +as_nop=as_fn_nop # as_fn_mkdir_p # ------------- @@ -322,7 +332,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`$as_echo "$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" @@ -331,7 +341,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | +printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -370,12 +380,13 @@ as_fn_executable_p () # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null +then : eval 'as_fn_append () { eval $1+=\$2 }' -else +else $as_nop as_fn_append () { eval $1=\$$1\$2 @@ -387,18 +398,27 @@ fi # as_fn_append # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null +then : eval 'as_fn_arith () { as_val=$(( $* )) }' -else +else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith +# as_fn_nop +# --------- +# Do nothing but, unlike ":", preserve the value of $?. +as_fn_nop () +{ + return $? +} +as_nop=as_fn_nop # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- @@ -410,9 +430,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 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - $as_echo "$as_me: error: $2" >&2 + printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error @@ -439,7 +459,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | +printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -483,7 +503,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || - { $as_echo "$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 @@ -497,6 +517,10 @@ 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*) @@ -510,6 +534,13 @@ case `echo -n x` in #((((( 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_echo='printf %s\n' +as_echo_n='printf %s' + + rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -575,51 +606,47 @@ MFLAGS= MAKEFLAGS= # Identity of this package. -PACKAGE_NAME= -PACKAGE_TARNAME= -PACKAGE_VERSION= -PACKAGE_STRING= -PACKAGE_BUGREPORT= -PACKAGE_URL= +PACKAGE_NAME='' +PACKAGE_TARNAME='' +PACKAGE_VERSION='' +PACKAGE_STRING='' +PACKAGE_BUGREPORT='' +PACKAGE_URL='' ac_unique_file="mmakefile" # Factoring default headers for most tests. ac_includes_default="\ -#include -#ifdef HAVE_SYS_TYPES_H -# include -#endif -#ifdef HAVE_SYS_STAT_H -# include +#include +#ifdef HAVE_STDIO_H +# include #endif -#ifdef STDC_HEADERS +#ifdef HAVE_STDLIB_H # include -# include -#else -# ifdef HAVE_STDLIB_H -# include -# endif #endif #ifdef HAVE_STRING_H -# if !defined STDC_HEADERS && defined HAVE_MEMORY_H -# include -# endif # include #endif -#ifdef HAVE_STRINGS_H -# include -#endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif #ifdef HAVE_UNISTD_H # include #endif" -ac_header_list= +ac_header_c_list= +ac_func_c_list= ac_subst_vars='LTLIBOBJS config_prefs_set aros_usb30_code @@ -834,9 +861,9 @@ pkgpyexecdir pyexecdir pkgpythondir pythondir -PYTHON_PLATFORM PYTHON_EXEC_PREFIX PYTHON_PREFIX +PYTHON_PLATFORM PYTHON_VERSION PYTHON PATCH @@ -934,6 +961,9 @@ enable_option_checking with_aros_prefs with_c_compiler with_cxx_compiler +with_python_sys_prefix +with_python_prefix +with_python_exec_prefix enable_libpng_config with_toolchain enable_lto @@ -1075,8 +1105,6 @@ do *) ac_optarg=yes ;; esac - # Accept the important Cygnus configure options, so we can diagnose typos. - case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; @@ -1117,9 +1145,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" + as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1143,9 +1171,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: $ac_useropt" + as_fn_error $? "invalid feature name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" @@ -1356,9 +1384,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" + as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1372,9 +1400,9 @@ do ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: $ac_useropt" + as_fn_error $? "invalid package name: \`$ac_useropt'" ac_useropt_orig=$ac_useropt - ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" @@ -1418,9 +1446,9 @@ Try \`$0 --help' for more information" *) # FIXME: should be removed in autoconf 3.0. - $as_echo "$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 && - $as_echo "$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}" ;; @@ -1436,7 +1464,7 @@ if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; - *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi @@ -1500,7 +1528,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_myself" | +printf "%s\n" X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -1696,6 +1724,11 @@ Optional Packages: Use specified c compiler for building AROS --with-cxx-compiler=VERSION Use specified c++ compiler building AROS + --with-python-sys-prefix + use Python's sys.prefix and sys.exec_prefix values + --with-python_prefix override the default PYTHON_PREFIX + --with-python_exec_prefix + override the default PYTHON_EXEC_PREFIX --with-toolchain=family Which toolchain family to crosscompile with (defaults to gnu) --with-kernel-gcc-version=VERSION @@ -1791,9 +1824,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=/`$as_echo "$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=`$as_echo "$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/ ;; @@ -1821,7 +1854,8 @@ esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } - # Check for guested configure. + # Check for configure.gnu first; this name is used for a wrapper for + # Metaconfig's "Configure" on case-insensitive file systems. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive @@ -1829,7 +1863,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix echo && $SHELL "$ac_srcdir/configure" --help=recursive else - $as_echo "$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 @@ -1839,9 +1873,9 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF configure -generated by GNU Autoconf 2.69 +generated by GNU Autoconf 2.71 -Copyright (C) 2012 Free Software Foundation, Inc. +Copyright (C) 2021 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1858,14 +1892,14 @@ fi ac_fn_cxx_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext + rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" 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\"" -$as_echo "$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 @@ -1873,14 +1907,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - } && test -s conftest.$ac_objext; then : + } && test -s conftest.$ac_objext +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1896,14 +1931,14 @@ fi ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext + rm -f conftest.$ac_objext conftest.beam if { { ac_try="$ac_compile" 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\"" -$as_echo "$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 @@ -1911,14 +1946,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - } && test -s conftest.$ac_objext; then : + } && test -s conftest.$ac_objext +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1940,7 +1976,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$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 @@ -1948,14 +1984,15 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 - }; then : + } +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -1971,14 +2008,14 @@ fi ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - rm -f conftest.$ac_objext conftest$ac_exeext + rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext if { { ac_try="$ac_link" 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\"" -$as_echo "$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 @@ -1986,17 +2023,18 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi - $as_echo "$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 } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext - }; then : + } +then : ac_retval=0 -else - $as_echo "$as_me: failed program was:" >&5 +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 @@ -2011,135 +2049,6 @@ fi } # ac_fn_c_try_link -# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES -# ------------------------------------------------------- -# Tests whether HEADER exists, giving a warning if it cannot be compiled using -# the include files in INCLUDES and setting the cache variable VAR -# accordingly. -ac_fn_c_check_header_mongrel () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if eval \${$3+:} false; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -else - # Is the header compilable? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 -$as_echo_n "checking $2 usability... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -$4 -#include <$2> -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_header_compiler=yes -else - ac_header_compiler=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 -$as_echo "$ac_header_compiler" >&6; } - -# Is the header present? -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 -$as_echo_n "checking $2 presence... " >&6; } -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include <$2> -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - ac_header_preproc=yes -else - ac_header_preproc=no -fi -rm -f conftest.err conftest.i conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 -$as_echo "$ac_header_preproc" >&6; } - -# So? What about this header? -case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( - yes:no: ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 -$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; - no:yes:* ) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 -$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 -$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 -$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 -$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 -$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else - eval "$3=\$ac_header_compiler" -fi -eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -fi - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - -} # ac_fn_c_check_header_mongrel - -# ac_fn_c_try_run LINENO -# ---------------------- -# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes -# that executables *can* be run. -ac_fn_c_try_run () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_link" -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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_link") 2>&5 - ac_status=$? - $as_echo "$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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_try") 2>&5 - ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; }; then : - ac_retval=0 -else - $as_echo "$as_me: program exited with status $ac_status" >&5 - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=$ac_status -fi - rm -rf conftest.dSYM conftest_ipa8_conftest.oo - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_c_try_run - # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in @@ -2147,26 +2056,28 @@ fi ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 @@ -2178,16 +2089,17 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_member () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5 -$as_echo_n "checking for $2.$3... " >&6; } -if eval \${$4+:} false; then : - $as_echo_n "(cached) " >&6 -else + { 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int -main () +main (void) { static $2 ac_aggr; if (ac_aggr.$3) @@ -2196,14 +2108,15 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$4=yes" -else +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $5 int -main () +main (void) { static $2 ac_aggr; if (sizeof ac_aggr.$3) @@ -2212,41 +2125,45 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$4=yes" -else +else $as_nop eval "$4=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$4 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 -# ac_fn_c_check_decl LINENO SYMBOL VAR INCLUDES -# --------------------------------------------- +# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR +# ------------------------------------------------------------------ # Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR -# accordingly. -ac_fn_c_check_decl () +# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR. +ac_fn_check_decl () { 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 "checking whether $as_decl_name is declared... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'` - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5 -$as_echo_n "checking whether $as_decl_name is declared... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + eval ac_save_FLAGS=\$$6 + as_fn_append $6 " $5" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { #ifndef $as_decl_name #ifdef __cplusplus @@ -2260,19 +2177,22 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + eval $6=\$ac_save_FLAGS + fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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_decl +} # ac_fn_check_decl # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- @@ -2281,17 +2201,18 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { if (sizeof ($2)) return 0; @@ -2299,12 +2220,13 @@ if (sizeof ($2)) return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int -main () +main (void) { if (sizeof (($2))) return 0; @@ -2312,18 +2234,19 @@ if (sizeof (($2))) return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : -else +else $as_nop eval "$3=yes" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 @@ -2334,11 +2257,12 @@ $as_echo "$ac_res" >&6; } ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 -$as_echo_n "checking for $2... " >&6; } -if eval \${$3+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +printf %s "checking for $2... " >&6; } +if eval test \${$3+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. @@ -2346,16 +2270,9 @@ else #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $2 (); below. - Prefer to if __STDC__ is defined, since - exists even on freestanding compilers. */ - -#ifdef __STDC__ -# include -#else -# include -#endif + which can conflict with char $2 (); below. */ +#include #undef $2 /* Override any GCC internal prototype to avoid an error. @@ -2373,35 +2290,99 @@ choke me #endif int -main () +main (void) { return $2 (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : eval "$3=yes" -else +else $as_nop eval "$3=no" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$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 + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that +# executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +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 + (eval "$ac_link") 2>&5 + ac_status=$? + 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 + (eval "$ac_try") 2>&5 + ac_status=$? + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; } +then : + ac_retval=0 +else $as_nop + 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 +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run +ac_configure_args_raw= +for ac_arg +do + case $ac_arg in + *\'*) + ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append ac_configure_args_raw " '$ac_arg'" +done + +case $ac_configure_args_raw in + *$as_nl*) + ac_safe_unquote= ;; + *) + 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"`;; +esac + cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by $as_me, which was -generated by GNU Autoconf 2.69. Invocation command line was +generated by GNU Autoconf 2.71. Invocation command line was - $ $0 $@ + $ $0$ac_configure_args_raw _ACEOF exec 5>>config.log @@ -2434,8 +2415,12 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - $as_echo "PATH: $as_dir" + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + printf "%s\n" "PATH: $as_dir" done IFS=$as_save_IFS @@ -2470,7 +2455,7 @@ do | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) - ac_arg=`$as_echo "$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'" ;; @@ -2505,11 +2490,13 @@ done # 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 - $as_echo "## ---------------- ## + printf "%s\n" "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo @@ -2520,8 +2507,8 @@ trap 'exit_status=$? case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$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) ;; #( @@ -2545,7 +2532,7 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; ) echo - $as_echo "## ----------------- ## + printf "%s\n" "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo @@ -2553,14 +2540,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - $as_echo "$ac_var='\''$ac_val'\''" + printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then - $as_echo "## ------------------- ## + printf "%s\n" "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo @@ -2568,15 +2555,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; do eval ac_val=\$$ac_var case $ac_val in - *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac - $as_echo "$ac_var='\''$ac_val'\''" + printf "%s\n" "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then - $as_echo "## ----------- ## + printf "%s\n" "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo @@ -2584,8 +2571,8 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; echo fi test "$ac_signal" != 0 && - $as_echo "$as_me: caught signal $ac_signal" - $as_echo "$as_me: exit $exit_status" + printf "%s\n" "$as_me: caught signal $ac_signal" + printf "%s\n" "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && @@ -2599,63 +2586,48 @@ ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h -$as_echo "/* confdefs.h */" > confdefs.h +printf "%s\n" "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. -cat >>confdefs.h <<_ACEOF -#define PACKAGE_NAME "$PACKAGE_NAME" -_ACEOF +printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_TARNAME "$PACKAGE_TARNAME" -_ACEOF +printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_VERSION "$PACKAGE_VERSION" -_ACEOF +printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_STRING "$PACKAGE_STRING" -_ACEOF +printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" -_ACEOF +printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define PACKAGE_URL "$PACKAGE_URL" -_ACEOF +printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. -ac_site_file1=NONE -ac_site_file2=NONE if test -n "$CONFIG_SITE"; then - # We do not want a PATH search for config.site. - case $CONFIG_SITE in #(( - -*) ac_site_file1=./$CONFIG_SITE;; - */*) ac_site_file1=$CONFIG_SITE;; - *) ac_site_file1=./$CONFIG_SITE;; - esac + ac_site_files="$CONFIG_SITE" elif test "x$prefix" != xNONE; then - ac_site_file1=$prefix/share/config.site - ac_site_file2=$prefix/etc/config.site + ac_site_files="$prefix/share/config.site $prefix/etc/config.site" else - ac_site_file1=$ac_default_prefix/share/config.site - ac_site_file2=$ac_default_prefix/etc/config.site + ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" fi -for ac_site_file in "$ac_site_file1" "$ac_site_file2" + +for ac_site_file in $ac_site_files do - test "x$ac_site_file" = xNONE && continue - if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 -$as_echo "$as_me: loading site script $ac_site_file" >&6;} + case $ac_site_file in #( + */*) : + ;; #( + *) : + 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;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ - || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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 @@ -2665,144 +2637,752 @@ 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 -$as_echo "$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 -as_fn_append ac_header_list " stdlib.h" -as_fn_append ac_header_list " unistd.h" -as_fn_append ac_header_list " sys/param.h" -# Check that the precious variables saved in the cache have kept the same -# value. -ac_cache_corrupted=false -for ac_var in $ac_precious_vars; do - eval ac_old_set=\$ac_cv_env_${ac_var}_set - eval ac_new_set=\$ac_env_${ac_var}_set - eval ac_old_val=\$ac_cv_env_${ac_var}_value - eval ac_new_val=\$ac_env_${ac_var}_value - case $ac_old_set,$ac_new_set in - set,) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,set) - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 -$as_echo "$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` - if test "$ac_old_val_w" != "$ac_new_val_w"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 -$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - ac_cache_corrupted=: - else - { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 -$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} - eval $ac_var=\$ac_old_val - fi - { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 -$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 -$as_echo "$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=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; - *) ac_arg=$ac_var=$ac_new_val ;; - esac - case " $ac_configure_args " in - *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) as_fn_append ac_configure_args " '$ac_arg'" ;; - esac - fi -done -if $ac_cache_corrupted; then - { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} - { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 -$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} - as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 -fi -## -------------------- ## -## Main body of script. ## -## -------------------- ## +# Test code for whether the C++ compiler supports C++98 (global declarations) +ac_cxx_conftest_cxx98_globals=' +// Does the compiler advertise C++98 conformance? +#if !defined __cplusplus || __cplusplus < 199711L +# error "Compiler does not advertise C++98 conformance" +#endif -ac_ext=c -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 +// These inclusions are to reject old compilers that +// lack the unsuffixed header files. +#include +#include +// and are *not* freestanding headers in C++98. +extern void assert (int); +namespace std { + extern int strcmp (const char *, const char *); +} +// Namespaces, exceptions, and templates were all added after "C++ 2.0". +using std::exception; +using std::strcmp; -ac_aux_dir= -for ac_dir in scripts/autoconf "$srcdir"/scripts/autoconf; do - if test -f "$ac_dir/install-sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install-sh -c" - break - elif test -f "$ac_dir/install.sh"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/install.sh -c" - break - elif test -f "$ac_dir/shtool"; then - ac_aux_dir=$ac_dir - ac_install_sh="$ac_aux_dir/shtool install -c" +namespace { + +void test_exception_syntax() +{ + try { + throw "test"; + } catch (const char *s) { + // Extra parentheses suppress a warning when building autoconf itself, + // due to lint rules shared with more typical C programs. + assert (!(strcmp) (s, "test")); + } +} + +template struct test_template +{ + T const val; + explicit test_template(T t) : val(t) {} + template T add(U u) { return static_cast(u) + val; } +}; + +} // anonymous namespace +' + +# Test code for whether the C++ compiler supports C++98 (body of main) +ac_cxx_conftest_cxx98_main=' + assert (argc); + assert (! argv[0]); +{ + test_exception_syntax (); + test_template tt (2.0); + assert (tt.add (4) == 6.0); + assert (true && !false); +} +' + +# Test code for whether the C++ compiler supports C++11 (global declarations) +ac_cxx_conftest_cxx11_globals=' +// Does the compiler advertise C++ 2011 conformance? +#if !defined __cplusplus || __cplusplus < 201103L +# error "Compiler does not advertise C++11 conformance" +#endif + +namespace cxx11test +{ + constexpr int get_val() { return 20; } + + struct testinit + { + int i; + double d; + }; + + class delegate + { + public: + delegate(int n) : n(n) {} + delegate(): delegate(2354) {} + + virtual int getval() { return this->n; }; + protected: + int n; + }; + + class overridden : public delegate + { + public: + overridden(int n): delegate(n) {} + virtual int getval() override final { return this->n * 2; } + }; + + class nocopy + { + public: + nocopy(int i): i(i) {} + nocopy() = default; + nocopy(const nocopy&) = delete; + nocopy & operator=(const nocopy&) = delete; + private: + int i; + }; + + // for testing lambda expressions + template Ret eval(Fn f, Ret v) + { + return f(v); + } + + // for testing variadic templates and trailing return types + template auto sum(V first) -> V + { + return first; + } + template auto sum(V first, Args... rest) -> V + { + return first + sum(rest...); + } +} +' + +# Test code for whether the C++ compiler supports C++11 (body of main) +ac_cxx_conftest_cxx11_main=' +{ + // Test auto and decltype + auto a1 = 6538; + auto a2 = 48573953.4; + auto a3 = "String literal"; + + int total = 0; + for (auto i = a3; *i; ++i) { total += *i; } + + decltype(a2) a4 = 34895.034; +} +{ + // Test constexpr + short sa[cxx11test::get_val()] = { 0 }; +} +{ + // Test initializer lists + cxx11test::testinit il = { 4323, 435234.23544 }; +} +{ + // Test range-based for + int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3, + 14, 19, 17, 8, 6, 20, 16, 2, 11, 1}; + for (auto &x : array) { x += 23; } +} +{ + // Test lambda expressions + using cxx11test::eval; + assert (eval ([](int x) { return x*2; }, 21) == 42); + double d = 2.0; + assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0); + assert (d == 5.0); + assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0); + assert (d == 5.0); +} +{ + // Test use of variadic templates + using cxx11test::sum; + auto a = sum(1); + auto b = sum(1, 2); + auto c = sum(1.0, 2.0, 3.0); +} +{ + // Test constructor delegation + cxx11test::delegate d1; + cxx11test::delegate d2(); + cxx11test::delegate d3(45); +} +{ + // Test override and final + cxx11test::overridden o1(55464); +} +{ + // Test nullptr + char *c = nullptr; +} +{ + // Test template brackets + test_template<::test_template> v(test_template(12)); +} +{ + // Unicode literals + char const *utf8 = u8"UTF-8 string \u2500"; + char16_t const *utf16 = u"UTF-8 string \u2500"; + char32_t const *utf32 = U"UTF-32 string \u2500"; +} +' + +# Test code for whether the C compiler supports C++11 (complete). +ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals} +${ac_cxx_conftest_cxx11_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_cxx_conftest_cxx98_main} + ${ac_cxx_conftest_cxx11_main} + return ok; +} +" + +# Test code for whether the C compiler supports C++98 (complete). +ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals} +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_cxx_conftest_cxx98_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 + +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ +struct buf { int x; }; +struct buf * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not \xHH hex character constants. + These do not provoke an error unfortunately, instead are silently treated + as an "x". The following induces an error, until -std is added to get + proper ANSI mode. Curiously \x00 != x always comes out true, for an + array size at least. It is necessary to write \x00 == 0 to get something + that is true only with -std. */ +int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) '\''x'\'' +int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int), + int, int);' + +# Test code for whether the C compiler supports C89 (body of main). +ac_c_conftest_c89_main=' +ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); +' + +# Test code for whether the C compiler supports C99 (global declarations) +ac_c_conftest_c99_globals=' +// Does the compiler advertise C99 conformance? +#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L +# error "Compiler does not advertise C99 conformance" +#endif + +#include +extern int puts (const char *); +extern int printf (const char *, ...); +extern int dprintf (int, const char *, ...); +extern void *malloc (size_t); + +// 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. +#define debug(...) dprintf (2, __VA_ARGS__) +#define showlist(...) puts (#__VA_ARGS__) +#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) +static void +test_varargs_macros (void) +{ + int x = 1234; + int y = 5678; + debug ("Flag"); + debug ("X = %d\n", x); + showlist (The first, second, and third items.); + report (x>y, "x is %d but y is %d", x, y); +} + +// Check long long types. +#define BIG64 18446744073709551615ull +#define BIG32 4294967295ul +#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) +#if !BIG_OK + #error "your preprocessor is broken" +#endif +#if BIG_OK +#else + #error "your preprocessor is broken" +#endif +static long long int bignum = -9223372036854775807LL; +static unsigned long long int ubignum = BIG64; + +struct incomplete_array +{ + int datasize; + double data[]; +}; + +struct named_init { + int number; + const wchar_t *name; + double average; +}; + +typedef const char *ccp; + +static inline int +test_restrict (ccp restrict text) +{ + // See if C++-style comments work. + // Iterate through items via the restricted pointer. + // Also check for declarations in for loops. + for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) + continue; + return 0; +} + +// Check varargs and va_copy. +static bool +test_varargs (const char *format, ...) +{ + va_list args; + va_start (args, format); + va_list args_copy; + va_copy (args_copy, args); + + const char *str = ""; + int number = 0; + float fnumber = 0; + + while (*format) + { + switch (*format++) + { + case '\''s'\'': // string + str = va_arg (args_copy, const char *); + break; + case '\''d'\'': // int + number = va_arg (args_copy, int); + break; + case '\''f'\'': // float + fnumber = va_arg (args_copy, double); + break; + default: + break; + } + } + va_end (args_copy); + va_end (args); + + return *str && number && fnumber; +} +' + +# Test code for whether the C compiler supports C99 (body of main). +ac_c_conftest_c99_main=' + // Check bool. + _Bool success = false; + success |= (argc != 0); + + // Check restrict. + if (test_restrict ("String literal") == 0) + success = true; + 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)); + ia->datasize = 10; + for (int i = 0; i < ia->datasize; ++i) + ia->data[i] = i * 1.234; + + // Check named initializers. + struct named_init ni = { + .number = 34, + .name = L"Test wide string", + .average = 543.34343, + }; + + ni.number = 58; + + int dynamic_array[ni.number]; + dynamic_array[0] = argv[0][0]; + dynamic_array[ni.number - 1] = 543; + + // work around unused variable warnings + ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\'' + || dynamic_array[ni.number - 1] != 543); +' + +# Test code for whether the C compiler supports C11 (global declarations) +ac_c_conftest_c11_globals=' +// Does the compiler advertise C11 conformance? +#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L +# error "Compiler does not advertise C11 conformance" +#endif + +// Check _Alignas. +char _Alignas (double) aligned_as_double; +char _Alignas (0) no_special_alignment; +extern char aligned_as_int; +char _Alignas (0) _Alignas (int) aligned_as_int; + +// Check _Alignof. +enum +{ + int_alignment = _Alignof (int), + int_array_alignment = _Alignof (int[100]), + char_alignment = _Alignof (char) +}; +_Static_assert (0 < -_Alignof (int), "_Alignof is signed"); + +// Check _Noreturn. +int _Noreturn does_not_return (void) { for (;;) continue; } + +// Check _Static_assert. +struct test_static_assert +{ + int x; + _Static_assert (sizeof (int) <= sizeof (long int), + "_Static_assert does not work in struct"); + long int y; +}; + +// Check UTF-8 literals. +#define u8 syntax error! +char const utf8_literal[] = u8"happens to be ASCII" "another string"; + +// Check duplicate typedefs. +typedef long *long_ptr; +typedef long int *long_ptr; +typedef long_ptr long_ptr; + +// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1. +struct anonymous +{ + union { + struct { int i; int j; }; + struct { int k; long int l; } w; + }; + int m; +} v1; +' + +# Test code for whether the C compiler supports C11 (body of main). +ac_c_conftest_c11_main=' + _Static_assert ((offsetof (struct anonymous, i) + == offsetof (struct anonymous, w.k)), + "Anonymous union alignment botch"); + v1.i = 2; + v1.w.k = 5; + ok |= v1.i != 5; +' + +# Test code for whether the C compiler supports C11 (complete). +ac_c_conftest_c11_program="${ac_c_conftest_c89_globals} +${ac_c_conftest_c99_globals} +${ac_c_conftest_c11_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + ${ac_c_conftest_c99_main} + ${ac_c_conftest_c11_main} + return ok; +} +" + +# Test code for whether the C compiler supports C99 (complete). +ac_c_conftest_c99_program="${ac_c_conftest_c89_globals} +${ac_c_conftest_c99_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + ${ac_c_conftest_c99_main} + return ok; +} +" + +# Test code for whether the C compiler supports C89 (complete). +ac_c_conftest_c89_program="${ac_c_conftest_c89_globals} + +int +main (int argc, char **argv) +{ + int ok = 0; + ${ac_c_conftest_c89_main} + return ok; +} +" + +as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H" +as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H" +as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H" +as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H" +as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H" +as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H" +as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H" +as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H" +as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H" +as_fn_append ac_header_c_list " sys/time.h sys_time_h HAVE_SYS_TIME_H" +as_fn_append ac_header_c_list " sys/param.h sys_param_h HAVE_SYS_PARAM_H" +as_fn_append ac_func_c_list " getpagesize HAVE_GETPAGESIZE" + +# Auxiliary files required by this configure script. +ac_aux_files="config.guess config.sub" + +# Locations in which to look for auxiliary files. +ac_aux_dir_candidates="${srcdir}/scripts/autoconf" + +# Search for a directory containing all of the required auxiliary files, +# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates. +# If we don't find one directory that contains all the files we need, +# we report the set of missing files from the *first* directory in +# $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 +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in $ac_aux_dir_candidates +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + as_found=: + + 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 + do + # As a special case, if "install-sh" is required, that requirement + # can be satisfied by any of "install-sh", "install.sh", or "shtool", + # and $ac_install_sh is set appropriately for whichever one is found. + 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 + 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 + 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 + ac_install_sh="${as_dir}shtool install -c" + else + ac_aux_dir_found=no + if $ac_first_candidate; then + ac_missing_aux_files="${ac_missing_aux_files} install-sh" + else + break + fi + fi + else + if test -f "${as_dir}${ac_aux}"; then + 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 + ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}" + else + break + fi + fi + fi + done + if test "$ac_aux_dir_found" = yes; then + ac_aux_dir="$as_dir" break fi + ac_first_candidate=false + + as_found=false done -if test -z "$ac_aux_dir"; then - as_fn_error $? "cannot find install-sh, install.sh, or shtool in scripts/autoconf \"$srcdir\"/scripts/autoconf" "$LINENO" 5 +IFS=$as_save_IFS +if $as_found +then : + +else $as_nop + as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 fi + # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. -ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. -ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. -ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. +if test -f "${ac_aux_dir}config.guess"; then + ac_config_guess="$SHELL ${ac_aux_dir}config.guess" +fi +if test -f "${ac_aux_dir}config.sub"; then + ac_config_sub="$SHELL ${ac_aux_dir}config.sub" +fi +if test -f "$ac_aux_dir/configure"; then + ac_configure="$SHELL ${ac_aux_dir}configure" +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + 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;} + 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;} + 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` + 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;} + 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;} + 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;} + 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=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + 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;} + as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file' + and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +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 + + # Check what host we are running on. # If a target is not suggested, we use this one. # Note that what we call a target, Autoconf calls a host. -# Make sure we can run config.sub. -$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || - as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 -$as_echo_n "checking build system type... " >&6; } -if ${ac_cv_build+:} false; then : - $as_echo_n "(cached) " >&6 -else + + + # Make sure we can run config.sub. +$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 "checking build system type... " >&6; } +if test ${ac_cv_build+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_build_alias=$build_alias test "x$ac_build_alias" = x && - ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` + ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 -ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 +ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 -$as_echo "$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;; @@ -2821,21 +3401,22 @@ IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 -$as_echo_n "checking host system type... " >&6; } -if ${ac_cv_host+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else - ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || - as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 + ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` || + as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5 fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 -$as_echo "$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;; @@ -2872,8 +3453,8 @@ target_grub2_version=$default_grub2_version # Don't strip the version of the target yet, it might be # useful on some systems. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for AROS style target" >&5 -$as_echo_n "checking for AROS style target... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AROS style target" >&5 +printf %s "checking for AROS style target... " >&6; } if test "$target" = "NONE" ; then target=$host_os-$host_cpu @@ -2882,27 +3463,27 @@ else target=$host_os-$host_cpu fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target" >&5 -$as_echo "$target" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target" >&5 +printf "%s\n" "$target" >&6; } if test "$host_os" = "mingw32" ; then PWDCMD="pwd -W" fi # Don't know where else to put this... -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking building AROS in" >&5 -$as_echo_n "checking building AROS in... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking building AROS in" >&5 +printf %s "checking building AROS in... " >&6; } AROS_BUILDDIR=`${PWDCMD-pwd}` AROS_BUILDDIR_UNIX=${PWD} -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_BUILDDIR" >&5 -$as_echo "$AROS_BUILDDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_BUILDDIR" >&5 +printf "%s\n" "$AROS_BUILDDIR" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS source in" >&5 -$as_echo_n "checking AROS source in... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking AROS source in" >&5 +printf %s "checking AROS source in... " >&6; } srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}` SRCDIR=${srcpwd} -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SRCDIR" >&5 -$as_echo "$SRCDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SRCDIR" >&5 +printf "%s\n" "$SRCDIR" >&6; } # Parse the target field into something useful. @@ -2911,23 +3492,24 @@ target_cpu=`echo $target | sed 's/^\([^-].*\)-\(.*\)$/\2/'` # Some debug output, to be removed again. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target system (debug output)" >&5 -$as_echo_n "checking for target system (debug output)... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_os" >&5 -$as_echo "$target_os" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for target cpu (debug output)" >&5 -$as_echo_n "checking for target cpu (debug output)... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_cpu" >&5 -$as_echo "$target_cpu" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target system (debug output)" >&5 +printf %s "checking for target system (debug output)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_os" >&5 +printf "%s\n" "$target_os" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target cpu (debug output)" >&5 +printf %s "checking for target cpu (debug output)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_cpu" >&5 +printf "%s\n" "$target_cpu" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which prefs set to use" >&5 -$as_echo_n "checking which prefs set to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which prefs set to use" >&5 +printf %s "checking which prefs set to use... " >&6; } # Check whether --with-aros-prefs was given. -if test "${with_aros_prefs+set}" = set; then : +if test ${with_aros_prefs+y} +then : withval=$with_aros_prefs; config_prefs_set="$withval" -else +else $as_nop config_prefs_set="" fi @@ -2936,8 +3518,8 @@ if test "$config_prefs_set" != "" ; then else msg_result="default" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } aros_dist_name=AROS aros_dist_version=ABIv1 @@ -2958,9 +3540,10 @@ HOST_WANTS_DLOPEN= default_c_compilers="gcc clang cc" # Check whether --with-c-compiler was given. -if test "${with_c_compiler+set}" = set; then : +if test ${with_c_compiler+y} +then : withval=$with_c_compiler; use_c_compiler="$withval" -else +else $as_nop use_c_compiler="" fi @@ -2974,9 +3557,10 @@ fi default_cxx_compilers="g++ clang++ c++" # Check whether --with-cxx-compiler was given. -if test "${with_cxx_compiler+set}" = set; then : +if test ${with_cxx_compiler+y} +then : withval=$with_cxx_compiler; use_cxx_compiler="$withval" -else +else $as_nop use_cxx_compiler="" fi @@ -2992,6 +3576,12 @@ fi # Check for a compiler. # Due to a bug in autoconf check for c++ compiler first. # For mor info see, http://osdir.com/ml/bug-autoconf-gnu/2010-05/msg00001.html. + + + + + + ac_ext=cpp ac_cpp='$CXXCPP $CPPFLAGS' ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' @@ -3006,11 +3596,12 @@ if test -z "$CXX"; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CXX"; then ac_cv_prog_CXX="$CXX" # Let the user override the test. else @@ -3018,11 +3609,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" - $as_echo "$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 @@ -3033,11 +3628,11 @@ fi fi CXX=$ac_cv_prog_CXX if test -n "$CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -$as_echo "$CXX" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf "%s\n" "$CXX" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -3050,11 +3645,12 @@ 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ac_ct_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$ac_ct_CXX"; then ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. else @@ -3062,11 +3658,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CXX="$ac_prog" - $as_echo "$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 @@ -3077,11 +3677,11 @@ fi fi ac_ct_CXX=$ac_cv_prog_ac_ct_CXX if test -n "$ac_ct_CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -3093,8 +3693,8 @@ done else case $cross_compiling:$ac_tool_warned in yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$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 @@ -3104,7 +3704,7 @@ fi fi fi # Provide some information about the compiler. -$as_echo "$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; do @@ -3114,7 +3714,7 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$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 @@ -3124,7 +3724,7 @@ $as_echo "$ac_try_echo"; } >&5 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done @@ -3132,7 +3732,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; @@ -3144,9 +3744,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. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5 -$as_echo_n "checking whether the C++ compiler works... " >&6; } -ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` +{ 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[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" @@ -3167,11 +3767,12 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : + 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'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, @@ -3188,7 +3789,7 @@ do # certainly right. break;; *.* ) - if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi @@ -3204,44 +3805,46 @@ do done test "$ac_cv_exeext" = no && ac_cv_exeext= -else +else $as_nop ac_file='' fi -if test -z "$ac_file"; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -$as_echo "$as_me: failed program was:" >&5 +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 sed 's/^/| /' conftest.$ac_ext >&5 -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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 - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5 -$as_echo_n "checking for C++ compiler default output file name... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 -$as_echo "$ac_file" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } +fi +{ 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; } 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 -$as_echo_n "checking for suffix of executables... " >&6; } +{ 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 *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : + 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) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with @@ -3255,15 +3858,15 @@ for ac_file in conftest.exe conftest conftest.*; do * ) break;; esac done -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +else $as_nop + { { 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; } fi rm -f conftest conftest$ac_cv_exeext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 -$as_echo "$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 @@ -3272,7 +3875,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int -main () +main (void) { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; @@ -3284,8 +3887,8 @@ _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. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 -$as_echo_n "checking whether we are cross compiling... " >&6; } +{ 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" case "(($ac_try" in @@ -3293,10 +3896,10 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? - $as_echo "$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 @@ -3304,39 +3907,40 @@ $as_echo "$ac_try_echo"; } >&5 *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? - $as_echo "$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 - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "cannot run C++ compiled programs. + { { 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 -$as_echo "$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.out ac_clean_files=$ac_clean_files_save -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 -$as_echo_n "checking for suffix of object files... " >&6; } -if ${ac_cv_objext+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; @@ -3350,342 +3954,46 @@ case "(($ac_try" in *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -$as_echo "$ac_try_echo"; } >&5 +printf "%s\n" "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? - $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; }; then : - for ac_file in conftest.o conftest.obj conftest.*; do - test -f "$ac_file" || continue; - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done -else - $as_echo "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - -{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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; } -fi -rm -f conftest.$ac_cv_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 -$as_echo "$ac_cv_objext" >&6; } -OBJEXT=$ac_cv_objext -ac_objext=$OBJEXT -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 -$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } -if ${ac_cv_cxx_compiler_gnu+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ -#ifndef __GNUC__ - choke me -#endif - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_compiler_gnu=yes -else - ac_compiler_gnu=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_cxx_compiler_gnu=$ac_compiler_gnu - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 -$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } -if test $ac_compiler_gnu = yes; then - GXX=yes -else - GXX= -fi -ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 -$as_echo_n "checking whether $CXX accepts -g... " >&6; } -if ${ac_cv_prog_cxx_g+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_save_cxx_werror_flag=$ac_cxx_werror_flag - ac_cxx_werror_flag=yes - ac_cv_prog_cxx_g=no - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -else - CXXFLAGS="" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - -else - ac_cxx_werror_flag=$ac_save_cxx_werror_flag - CXXFLAGS="-g" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -int -main () -{ - - ; - return 0; -} -_ACEOF -if ac_fn_cxx_try_compile "$LINENO"; then : - ac_cv_prog_cxx_g=yes -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_cxx_werror_flag=$ac_save_cxx_werror_flag -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 -$as_echo "$ac_cv_prog_cxx_g" >&6; } -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi -ac_ext=c -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 - -CXX_BASE=$CXX -# Extract the first word of "$CXX", so it can be a program name with args. -set dummy $CXX; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_CXX+:} false; then : - $as_echo_n "(cached) " >&6 -else - case $CXX in - [\\/]* | ?:[\\/]*) - ac_cv_path_CXX="$CXX" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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_CXX="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - ;; -esac -fi -CXX=$ac_cv_path_CXX -if test -n "$CXX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 -$as_echo "$CXX" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -ac_ext=c -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 -if test -n "$ac_tool_prefix"; then - for ac_prog in ${host_c_compilers} - 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CC+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$CC"; then - ac_cv_prog_CC="$CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -CC=$ac_cv_prog_CC -if test -n "$CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -$as_echo "$CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$CC" && break - done -fi -if test -z "$CC"; then - ac_ct_CC=$CC - for ac_prog in ${host_c_compilers} -do - # Extract the first word of "$ac_prog", so it can be a program name with args. -set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ac_ct_CC+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -n "$ac_ct_CC"; then - ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - -fi -fi -ac_ct_CC=$ac_cv_prog_ac_ct_CC -if test -n "$ac_ct_CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 -$as_echo "$ac_ct_CC" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - - test -n "$ac_ct_CC" && break -done - - if test "x$ac_ct_CC" = x; then - CC="" - else - case $cross_compiling:$ac_tool_warned in -yes:) -{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 -$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} -ac_tool_warned=yes ;; -esac - CC=$ac_ct_CC - fi -fi - - -test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$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. -$as_echo "$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; do - { { ac_try="$ac_compiler $ac_option >&5" -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\"" -$as_echo "$ac_try_echo"; } >&5 - (eval "$ac_compiler $ac_option >&5") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - sed '10a\ -... rest of stderr output deleted ... - 10q' conftest.err >conftest.er1 - cat conftest.er1 >&5 - fi - rm -f conftest.er1 conftest.err - $as_echo "$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 + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac done +else $as_nop + printf "%s\n" "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 -$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } -if ${ac_cv_c_compiler_gnu+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ { 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; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ 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 "checking whether the compiler supports GNU C++... " >&6; } +if test ${ac_cv_cxx_compiler_gnu+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { #ifndef __GNUC__ choke me @@ -3695,190 +4003,201 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_cxx_try_compile "$LINENO" +then : ac_compiler_gnu=yes -else +else $as_nop ac_compiler_gnu=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -ac_cv_c_compiler_gnu=$ac_compiler_gnu +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 -$as_echo "$ac_cv_c_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 - GCC=yes + GXX=yes else - GCC= + GXX= fi -ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 -$as_echo_n "checking whether $CC accepts -g... " >&6; } -if ${ac_cv_prog_cc_g+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_save_c_werror_flag=$ac_c_werror_flag - ac_c_werror_flag=yes - ac_cv_prog_cc_g=no - CFLAGS="-g" +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 "checking whether $CXX accepts -g... " >&6; } +if test ${ac_cv_prog_cxx_g+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes -else - CFLAGS="" +if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_g=yes +else $as_nop + CXXFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_cxx_try_compile "$LINENO" +then : -else - ac_c_werror_flag=$ac_save_c_werror_flag - CFLAGS="-g" +else $as_nop + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_g=yes +if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_g=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - ac_c_werror_flag=$ac_save_c_werror_flag +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 -$as_echo "$ac_cv_prog_cc_g" >&6; } -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O2" +{ 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 + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" else - CFLAGS="-g" + CXXFLAGS="-g" fi else - if test "$GCC" = yes; then - CFLAGS="-O2" + if test "$GXX" = yes; then + CXXFLAGS="-O2" else - CFLAGS= + CXXFLAGS= fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if ${ac_cv_prog_cc_c89+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_prog_cc_c89=no -ac_save_CC=$CC +ac_prog_cxx_stdcxx=no +if test x$ac_prog_cxx_stdcxx = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5 +printf %s "checking for $CXX option to enable C++11 features... " >&6; } +if test ${ac_cv_prog_cxx_11+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cxx_11=no +ac_save_CXX=$CXX cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -struct stat; -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv; -int -main () -{ -return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; - ; - return 0; -} +$ac_cxx_conftest_cxx11_program _ACEOF -for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA do - CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_prog_cc_c89=$ac_arg + CXX="$ac_save_CXX $ac_arg" + if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_cxx11=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext - test "x$ac_cv_prog_cc_c89" != "xno" && break +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cxx_cxx11" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC - +CXX=$ac_save_CXX +fi + +if test "x$ac_cv_prog_cxx_cxx11" = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf "%s\n" "unsupported" >&6; } +else $as_nop + if test "x$ac_cv_prog_cxx_cxx11" = x +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf "%s\n" "none needed" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5 +printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; } + CXX="$CXX $ac_cv_prog_cxx_cxx11" +fi + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11 + ac_prog_cxx_stdcxx=cxx11 +fi +fi +if test x$ac_prog_cxx_stdcxx = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5 +printf %s "checking for $CXX option to enable C++98 features... " >&6; } +if test ${ac_cv_prog_cxx_98+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cxx_98=no +ac_save_CXX=$CXX +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_cxx_conftest_cxx98_program +_ACEOF +for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA +do + CXX="$ac_save_CXX $ac_arg" + if ac_fn_cxx_try_compile "$LINENO" +then : + ac_cv_prog_cxx_cxx98=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cxx_cxx98" != "xno" && break +done +rm -f conftest.$ac_ext +CXX=$ac_save_CXX fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c89" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c89" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c89" != xno; then : +if test "x$ac_cv_prog_cxx_cxx98" = xno +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +printf "%s\n" "unsupported" >&6; } +else $as_nop + if test "x$ac_cv_prog_cxx_cxx98" = x +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +printf "%s\n" "none needed" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5 +printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; } + CXX="$CXX $ac_cv_prog_cxx_cxx98" +fi + ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98 + ac_prog_cxx_stdcxx=cxx98 +fi fi ac_ext=c @@ -3887,517 +4206,692 @@ 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 -CC_BASE=$CC -ac_ext=c -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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -$as_echo_n "checking how to run the C preprocessor... " >&6; } -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - if ${ac_cv_prog_CPP+:} false; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes +CXX_BASE=$CXX +# Extract the first word of "$CXX", so it can be a program name with args. +set dummy $CXX; ac_word=$2 +{ 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_CXX+y} +then : + printf %s "(cached) " >&6 +else $as_nop + case $CXX in + [\\/]* | ?:[\\/]*) + ac_cv_path_CXX="$CXX" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_CXX="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS -else - # Broken: fails on valid input. -continue + ;; +esac fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue +CXX=$ac_cv_path_CXX +if test -n "$CXX"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +printf "%s\n" "$CXX" >&6; } else - # Passes both tests. -ac_preproc_ok=: -break + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -rm -f conftest.err conftest.i conftest.$ac_ext -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : - break -fi - done - ac_cv_prog_CPP=$CPP -fi - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -$as_echo "$CPP" >&6; } -ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : -else - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : - # Broken: success on invalid input. -continue -else - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext + + + + + +ac_ext=c +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 +if test -n "$ac_tool_prefix"; then + for ac_prog in ${host_c_compilers} + 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 "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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 + break 2 + fi done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : + done +IFS=$as_save_IFS +fi +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; } else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -ac_ext=c -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 -CPP_BASE=$CPP -# Extract the first word of "$CC", so it can be a program name with args. -set dummy $CC; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_CC+:} false; then : - $as_echo_n "(cached) " >&6 + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in ${host_c_compilers} +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 "checking for $ac_word... " >&6; } +if test ${ac_cv_prog_ac_ct_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else - case $CC in - [\\/]* | ?:[\\/]*) - ac_cv_path_CC="$CC" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_CC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + 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 break 2 fi done done IFS=$as_save_IFS - ;; -esac fi -CC=$ac_cv_path_CC -if test -n "$CC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 -$as_echo "$CC" >&6; } +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; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -aros_host_def_cc="$CC" - case $ac_cv_prog_cc_stdc in #( - no) : - ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #( - *) : - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5 -$as_echo_n "checking for $CC option to accept ISO C99... " >&6; } -if ${ac_cv_prog_cc_c99+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_cv_prog_cc_c99=no -ac_save_CC=$CC -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include -#include + test -n "$ac_ct_CC" && break +done -// Check varargs macros. These examples are taken from C99 6.10.3.5. -#define debug(...) fprintf (stderr, __VA_ARGS__) -#define showlist(...) puts (#__VA_ARGS__) -#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__)) -static void -test_varargs_macros (void) -{ - int x = 1234; - int y = 5678; - debug ("Flag"); - debug ("X = %d\n", x); - showlist (The first, second, and third items.); - report (x>y, "x is %d but y is %d", x, y); -} + if test "x$ac_ct_CC" = x; then + CC="" + 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;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi -// Check long long types. -#define BIG64 18446744073709551615ull -#define BIG32 4294967295ul -#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0) -#if !BIG_OK - your preprocessor is broken; -#endif -#if BIG_OK -#else - your preprocessor is broken; -#endif -static long long int bignum = -9223372036854775807LL; -static unsigned long long int ubignum = BIG64; -struct incomplete_array -{ - int datasize; - double data[]; -}; +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; } -struct named_init { - int number; - const wchar_t *name; - double average; -}; +# Provide some information about the compiler. +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 + { { ac_try="$ac_compiler $ac_option >&5" +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 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done -typedef const char *ccp; +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ -static inline int -test_restrict (ccp restrict text) +int +main (void) { - // See if C++-style comments work. - // Iterate through items via the restricted pointer. - // Also check for declarations in for loops. - for (unsigned int i = 0; *(text+i) != '\0'; ++i) - continue; +#ifndef __GNUC__ + choke me +#endif + + ; return 0; } +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_compiler_gnu=yes +else $as_nop + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu -// Check varargs and va_copy. -static void -test_varargs (const char *format, ...) -{ - va_list args; - va_start (args, format); - va_list args_copy; - va_copy (args_copy, args); - - const char *str; - int number; - float fnumber; +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; } +ac_compiler_gnu=$ac_cv_c_compiler_gnu - while (*format) - { - switch (*format++) - { - case 's': // string - str = va_arg (args_copy, const char *); - break; - case 'd': // int - number = va_arg (args_copy, int); - break; - case 'f': // float - fnumber = va_arg (args_copy, double); - break; - default: - break; - } - } - va_end (args_copy); - va_end (args); -} +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +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 "checking whether $CC accepts -g... " >&6; } +if test ${ac_cv_prog_cc_g+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ int -main () +main (void) { - // Check bool. - _Bool success = false; - - // Check restrict. - if (test_restrict ("String literal") == 0) - success = true; - char *restrict newvar = "Another string"; - - // Check varargs. - test_varargs ("s, d' f .", "string", 65, 34.234); - test_varargs_macros (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +else $as_nop + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ - // Check flexible array members. - struct incomplete_array *ia = - malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10)); - ia->datasize = 10; - for (int i = 0; i < ia->datasize; ++i) - ia->data[i] = i * 1.234; +int +main (void) +{ - // Check named initializers. - struct named_init ni = { - .number = 34, - .name = L"Test wide string", - .average = 543.34343, - }; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : - ni.number = 58; +else $as_nop + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ - int dynamic_array[ni.number]; - dynamic_array[ni.number - 1] = 543; +int +main (void) +{ - // work around unused variable warnings - return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x' - || dynamic_array[ni.number - 1] != 543); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +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; } +if test $ac_test_CFLAGS; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +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 "checking for $CC option to enable C11 features... " >&6; } +if test ${ac_cv_prog_cc_c11+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cc_c11=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c11_program +_ACEOF +for ac_arg in '' -std=gnu11 +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO" +then : + ac_cv_prog_cc_c11=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam + test "x$ac_cv_prog_cc_c11" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC +fi - ; - return 0; -} +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; } +else $as_nop + 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; } +else $as_nop + { 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" +fi + ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 + ac_prog_cc_stdc=c11 +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 "checking for $CC option to enable C99 features... " >&6; } +if test ${ac_cv_prog_cc_c99+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_cv_prog_cc_c99=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$ac_c_conftest_c99_program _ACEOF -for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99 +for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99= do CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : + if ac_fn_c_try_compile "$LINENO" +then : ac_cv_prog_cc_c99=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext +rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC +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; } +else $as_nop + 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; } +else $as_nop + { 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" fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c99" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c99" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 -$as_echo "$ac_cv_prog_cc_c99" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c99" != xno; then : ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 -else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 -$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } -if ${ac_cv_prog_cc_c89+:} false; then : - $as_echo_n "(cached) " >&6 -else + ac_prog_cc_stdc=c99 +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 "checking for $CC option to enable C89 features... " >&6; } +if test ${ac_cv_prog_cc_c89+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -struct stat; -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} - -/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has - function prototypes and stuff, but not '\xHH' hex character constants. - These don't provoke an error unfortunately, instead are silently treated - as 'x'. The following induces an error, until -std is added to get - proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an - array size at least. It's necessary to write '\x00'==0 to get something - that's true only with -std. */ -int osf4_cc_array ['\x00' == 0 ? 1 : -1]; - -/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters - inside strings and character constants. */ -#define FOO(x) 'x' -int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; - -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv; -int -main () -{ -return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; - ; - return 0; -} +$ac_c_conftest_c89_program _ACEOF -for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ - -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" - if ac_fn_c_try_compile "$LINENO"; then : + if ac_fn_c_try_compile "$LINENO" +then : ac_cv_prog_cc_c89=$ac_arg fi -rm -f core conftest.err conftest.$ac_objext +rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC +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; } +else $as_nop + 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; } +else $as_nop + { 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" fi -# AC_CACHE_VAL -case "x$ac_cv_prog_cc_c89" in - x) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; - xno) - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; - *) - CC="$CC $ac_cv_prog_cc_c89" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 -$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; -esac -if test "x$ac_cv_prog_cc_c89" != xno; then : ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 + ac_prog_cc_stdc=c89 +fi +fi + +ac_ext=c +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 + +CC_BASE=$CC +ac_ext=c +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 "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if test ${ac_cv_prog_CPP+y} +then : + printf %s "(cached) " >&6 +else $as_nop + # Double quotes because $CC needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + +else $as_nop + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + # Broken: success on invalid input. +continue +else $as_nop + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok +then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP else - ac_cv_prog_cc_stdc=no + ac_cv_prog_CPP=$CPP +fi +{ 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 + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + +else $as_nop + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO" +then : + # Broken: success on invalid input. +continue +else $as_nop + # Passes both tests. +ac_preproc_ok=: +break fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok +then : +else $as_nop + { { 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; } fi - ;; -esac - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5 -$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; } - if ${ac_cv_prog_cc_stdc+:} false; then : - $as_echo_n "(cached) " >&6 -fi - - case $ac_cv_prog_cc_stdc in #( - no) : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 -$as_echo "unsupported" >&6; } ;; #( - '') : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 -$as_echo "none needed" >&6; } ;; #( - *) : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5 -$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;; + +ac_ext=c +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 + +CPP_BASE=$CPP +# 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 "checking for $ac_word... " >&6; } +if test ${ac_cv_path_CC+y} +then : + printf %s "(cached) " >&6 +else $as_nop + case $CC in + [\\/]* | ?:[\\/]*) + ac_cv_path_CC="$CC" # Let the user override the test with a path. + ;; + *) + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_CC="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + ;; esac +fi +CC=$ac_cv_path_CC +if test -n "$CC"; then + { 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; } +fi + + +aros_host_def_cc="$CC" ac_ext=c 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -$as_echo_n "checking how to run the C preprocessor... " >&6; } +{ 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 CPP= fi if test -z "$CPP"; then - if ${ac_cv_prog_CPP+:} false; then : - $as_echo_n "(cached) " >&6 -else - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + if test ${ac_cv_prog_CPP+y} +then : + printf %s "(cached) " >&6 +else $as_nop + # Double quotes because $CC needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif +#include Syntax error _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : -else +else $as_nop # Broken: fails on valid input. continue fi @@ -4409,10 +4903,11 @@ rm -f conftest.err conftest.i conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # Broken: success on invalid input. continue -else +else $as_nop # Passes both tests. ac_preproc_ok=: break @@ -4422,7 +4917,8 @@ rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : +if $ac_preproc_ok +then : break fi @@ -4434,29 +4930,24 @@ fi else ac_cv_prog_CPP=$CPP fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -$as_echo "$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 # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. - # Prefer to if __STDC__ is defined, since - # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#ifdef __STDC__ -# include -#else -# include -#endif +#include Syntax error _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : -else +else $as_nop # Broken: fails on valid input. continue fi @@ -4468,10 +4959,11 @@ rm -f conftest.err conftest.i conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # Broken: success on invalid input. continue -else +else $as_nop # Passes both tests. ac_preproc_ok=: break @@ -4481,11 +4973,12 @@ rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok; then : +if $ac_preproc_ok +then : -else - { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +else $as_nop + { { 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; } fi @@ -4498,8 +4991,8 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu # detect the compiler version -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which toolchain family ${CC_BASE} belongs to" >&5 -$as_echo_n "checking which toolchain family ${CC_BASE} belongs to... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which toolchain family ${CC_BASE} belongs to" >&5 +printf %s "checking which toolchain family ${CC_BASE} belongs to... " >&6; } HOST_COMPILER_VERSION=`"$CC" --version 2>/dev/null` if test x"$HOST_COMPILER_VERSION" = "x"; then HOST_COMPILER_VERSION=`"$CC" --qversion 2>/dev/null` @@ -4535,19 +5028,20 @@ fi if test x"$HOST_TOOLCHAIN_FAMILY" = "x"; then HOST_TOOLCHAIN_FAMILY=unknown fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $HOST_TOOLCHAIN_FAMILY" >&5 -$as_echo "$HOST_TOOLCHAIN_FAMILY" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HOST_TOOLCHAIN_FAMILY" >&5 +printf "%s\n" "$HOST_TOOLCHAIN_FAMILY" >&6; } # Check for a compatible awk for ac_prog in gawk nawk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_AWK+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else @@ -4555,11 +5049,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AWK="$ac_prog" - $as_echo "$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 @@ -4570,11 +5068,11 @@ fi fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 -$as_echo "$AWK" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +printf "%s\n" "$AWK" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4593,11 +5091,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mmake", so it can be a program name with args. set dummy mmake; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MMAKE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MMAKE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MMAKE"; then ac_cv_prog_MMAKE="$MMAKE" # Let the user override the test. else @@ -4605,11 +5104,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MMAKE="mmake " - $as_echo "$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 @@ -4620,11 +5123,11 @@ fi fi MMAKE=$ac_cv_prog_MMAKE if test -n "$MMAKE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MMAKE" >&5 -$as_echo "$MMAKE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MMAKE" >&5 +printf "%s\n" "$MMAKE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4642,11 +5145,12 @@ if test "$HOST_TOOLCHAIN_FAMILY" = "llvm"; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_base_lld_name+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_base_lld_name+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$base_lld_name"; then ac_cv_prog_base_lld_name="$base_lld_name" # Let the user override the test. else @@ -4654,11 +5158,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_base_lld_name="$ac_prog" - $as_echo "$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 @@ -4669,11 +5177,11 @@ fi fi base_lld_name=$ac_cv_prog_base_lld_name if test -n "$base_lld_name"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $base_lld_name" >&5 -$as_echo "$base_lld_name" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $base_lld_name" >&5 +printf "%s\n" "$base_lld_name" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4684,11 +5192,12 @@ done else # Extract the first word of "$base_ld_name", so it can be a program name with args. set dummy $base_ld_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_LD_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_LD_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$LD_BASE"; then ac_cv_prog_LD_BASE="$LD_BASE" # Let the user override the test. else @@ -4696,11 +5205,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_LD_BASE="" - $as_echo "$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 @@ -4711,11 +5224,11 @@ fi fi LD_BASE=$ac_cv_prog_LD_BASE if test -n "$LD_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_BASE" >&5 -$as_echo "$LD_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD_BASE" >&5 +printf "%s\n" "$LD_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4730,11 +5243,12 @@ if test "$GCC" = "yes"; then aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. set dummy `basename $aros_gcc_ld`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. @@ -4744,11 +5258,15 @@ else for as_dir in `dirname $aros_gcc_ld` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4760,11 +5278,11 @@ esac fi aros_host_ld=$ac_cv_path_aros_host_ld if test -n "$aros_host_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 -$as_echo "$aros_host_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +printf "%s\n" "$aros_host_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4774,11 +5292,12 @@ if test "$aros_host_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ld="$aros_host_ld" # Let the user override the test with a path. @@ -4788,11 +5307,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -4804,11 +5327,11 @@ esac fi aros_host_ld=$ac_cv_path_aros_host_ld if test -n "$aros_host_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 -$as_echo "$aros_host_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ld" >&5 +printf "%s\n" "$aros_host_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4851,11 +5374,12 @@ for ac_prog in aclocal aclocal19 aclocal-1.9 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_aclocal+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_aclocal+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_aclocal"; then ac_cv_prog_aros_host_aclocal="$aros_host_aclocal" # Let the user override the test. else @@ -4863,11 +5387,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_aclocal="$ac_prog" - $as_echo "$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 @@ -4878,11 +5406,11 @@ fi fi aros_host_aclocal=$ac_cv_prog_aros_host_aclocal if test -n "$aros_host_aclocal"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_aclocal" >&5 -$as_echo "$aros_host_aclocal" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_aclocal" >&5 +printf "%s\n" "$aros_host_aclocal" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4893,11 +5421,12 @@ for ac_prog in autoconf autoconf259 autoconf253 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_autoconf+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_autoconf+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_autoconf"; then ac_cv_prog_aros_host_autoconf="$aros_host_autoconf" # Let the user override the test. else @@ -4905,11 +5434,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_autoconf="$ac_prog" - $as_echo "$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 @@ -4920,11 +5453,11 @@ fi fi aros_host_autoconf=$ac_cv_prog_aros_host_autoconf if test -n "$aros_host_autoconf"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoconf" >&5 -$as_echo "$aros_host_autoconf" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoconf" >&5 +printf "%s\n" "$aros_host_autoconf" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4935,11 +5468,12 @@ for ac_prog in autoheader autoheader259 autoheader253 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_autoheader+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_autoheader+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_autoheader"; then ac_cv_prog_aros_host_autoheader="$aros_host_autoheader" # Let the user override the test. else @@ -4947,11 +5481,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_autoheader="$ac_prog" - $as_echo "$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 @@ -4962,11 +5500,11 @@ fi fi aros_host_autoheader=$ac_cv_prog_aros_host_autoheader if test -n "$aros_host_autoheader"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoheader" >&5 -$as_echo "$aros_host_autoheader" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_autoheader" >&5 +printf "%s\n" "$aros_host_autoheader" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -4977,11 +5515,12 @@ for ac_prog in automake automake19 automake-1.9 do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_automake+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_automake+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_automake"; then ac_cv_prog_aros_host_automake="$aros_host_automake" # Let the user override the test. else @@ -4989,11 +5528,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_automake="$ac_prog" - $as_echo "$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 @@ -5004,11 +5547,11 @@ fi fi aros_host_automake=$ac_cv_prog_aros_host_automake if test -n "$aros_host_automake"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_automake" >&5 -$as_echo "$aros_host_automake" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_automake" >&5 +printf "%s\n" "$aros_host_automake" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5079,8 +5622,8 @@ case "$host_os" in aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5109,8 +5652,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="arm" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5137,16 +5680,17 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} ;; darwin*) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for macOS SDK files" >&5 -$as_echo_n "checking for macOS SDK files... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for macOS SDK files" >&5 +printf %s "checking for macOS SDK files... " >&6; } LOC=$( xcode-select -p ) - if test $? != 0; then : + if test $? != 0 +then : as_fn_error $? "XCode incorrectly configured! please run 'xcode-select --install' before re-running configure" "$LINENO" 5 fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LOC" >&5 -$as_echo "$LOC" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LOC" >&5 +printf "%s\n" "$LOC" >&6; } aros_host_cflags="$aros_host_cflags $aros_host_cc_pipe" aros_host_arch="darwin" host_cc_elf=no @@ -5165,8 +5709,8 @@ $as_echo "$LOC" >&6; } aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5187,8 +5731,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for Darwin host -- $host_cpu\"" >&2;} aros_host_cpu="x86_64" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5206,8 +5750,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="m68k" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5223,8 +5767,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="i386" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5241,8 +5785,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="sparc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5270,8 +5814,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="ppc" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5290,8 +5834,8 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="i386" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5310,11 +5854,11 @@ $as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} case "$host_cpu" in *i?86*) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Windows native gcc target" >&5 -$as_echo_n "checking for Windows native gcc target... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Windows native gcc target" >&5 +printf %s "checking for Windows native gcc target... " >&6; } host_cpu=`gcc -dumpmachine` - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_cpu" >&5 -$as_echo "$host_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $host_cpu" >&5 +printf "%s\n" "$host_cpu" >&6; } ;; esac @@ -5334,8 +5878,8 @@ $as_echo "$host_cpu" >&6; } ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown CPU for host -- $host_cpu\"" >&2;} aros_host_cpu="$host_cpu" ;; esac @@ -5348,11 +5892,12 @@ esac base_ar_name=${HOST_TOOLCHAIN_PREFIX}ar${HOST_TOOLCHAIN_SUFFIX} # Extract the first word of "$base_ar_name", so it can be a program name with args. set dummy $base_ar_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_AR_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$AR_BASE"; then ac_cv_prog_AR_BASE="$AR_BASE" # Let the user override the test. else @@ -5360,11 +5905,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_AR_BASE="$base_ar_name " - $as_echo "$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 @@ -5375,11 +5924,11 @@ fi fi AR_BASE=$ac_cv_prog_AR_BASE if test -n "$AR_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_BASE" >&5 -$as_echo "$AR_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR_BASE" >&5 +printf "%s\n" "$AR_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5387,11 +5936,12 @@ aros_host_ar_flags="cr" aros_host_cmd_ar="$AR_BASE $aros_host_ar_flags" # Extract the first word of "$aros_host_cmd_ar", so it can be a program name with args. set dummy $aros_host_cmd_ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_plain_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_plain_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_plain_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_plain_ar="$aros_host_plain_ar" # Let the user override the test with a path. @@ -5401,11 +5951,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_plain_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_plain_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5418,11 +5972,11 @@ esac fi aros_host_plain_ar=$ac_cv_path_aros_host_plain_ar if test -n "$aros_host_plain_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_plain_ar" >&5 -$as_echo "$aros_host_plain_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_plain_ar" >&5 +printf "%s\n" "$aros_host_plain_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5440,11 +5994,12 @@ fi base_ranlib_name=${HOST_TOOLCHAIN_PREFIX}ranlib${HOST_TOOLCHAIN_SUFFIX} # Extract the first word of "$base_ranlib_name", so it can be a program name with args. set dummy $base_ranlib_name; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_RANLIB_BASE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BASE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$RANLIB_BASE"; then ac_cv_prog_RANLIB_BASE="$RANLIB_BASE" # Let the user override the test. else @@ -5452,11 +6007,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RANLIB_BASE="$base_ranlib_name " - $as_echo "$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 @@ -5467,21 +6026,22 @@ fi fi RANLIB_BASE=$ac_cv_prog_RANLIB_BASE if test -n "$RANLIB_BASE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_BASE" >&5 -$as_echo "$RANLIB_BASE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB_BASE" >&5 +printf "%s\n" "$RANLIB_BASE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi # Extract the first word of "$RANLIB_BASE", so it can be a program name with args. set dummy $RANLIB_BASE; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_host_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_host_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_host_ranlib="$aros_host_ranlib" # Let the user override the test with a path. @@ -5491,11 +6051,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_host_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_host_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -5508,11 +6072,11 @@ esac fi aros_host_ranlib=$ac_cv_path_aros_host_ranlib if test -n "$aros_host_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_ranlib" >&5 -$as_echo "$aros_host_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_ranlib" >&5 +printf "%s\n" "$aros_host_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5528,11 +6092,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "strip", so it can be a program name with args. set dummy strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_aros_host_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_host_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$aros_host_strip"; then ac_cv_prog_aros_host_strip="$aros_host_strip" # Let the user override the test. else @@ -5540,11 +6105,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_aros_host_strip="strip " - $as_echo "$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 @@ -5555,11 +6124,11 @@ fi fi aros_host_strip=$ac_cv_prog_aros_host_strip if test -n "$aros_host_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_host_strip" >&5 -$as_echo "$aros_host_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_host_strip" >&5 +printf "%s\n" "$aros_host_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5576,11 +6145,12 @@ fi # Extract the first word of "rm", so it can be a program name with args. set dummy rm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_RM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_RM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$RM"; then ac_cv_prog_RM="$RM" # Let the user override the test. else @@ -5588,11 +6158,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_RM="rm -rf" - $as_echo "$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 @@ -5603,11 +6177,11 @@ fi fi RM=$ac_cv_prog_RM if test -n "$RM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 -$as_echo "$RM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5 +printf "%s\n" "$RM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5623,11 +6197,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "cp", so it can be a program name with args. set dummy cp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CP+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CP+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CP"; then ac_cv_prog_CP="$CP" # Let the user override the test. else @@ -5635,11 +6210,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CP="cp " - $as_echo "$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 @@ -5650,11 +6229,11 @@ fi fi CP=$ac_cv_prog_CP if test -n "$CP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 -$as_echo "$CP" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5 +printf "%s\n" "$CP" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5670,11 +6249,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mv", so it can be a program name with args. set dummy mv; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MV+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MV+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MV"; then ac_cv_prog_MV="$MV" # Let the user override the test. else @@ -5682,11 +6262,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MV="mv " - $as_echo "$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 @@ -5697,11 +6281,11 @@ fi fi MV=$ac_cv_prog_MV if test -n "$MV"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 -$as_echo "$MV" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5 +printf "%s\n" "$MV" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5717,11 +6301,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "echo", so it can be a program name with args. set dummy echo; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_ECHO+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_ECHO+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$ECHO"; then ac_cv_prog_ECHO="$ECHO" # Let the user override the test. else @@ -5729,11 +6314,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_ECHO="echo " - $as_echo "$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 @@ -5744,11 +6333,11 @@ fi fi ECHO=$ac_cv_prog_ECHO if test -n "$ECHO"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 -$as_echo "$ECHO" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5 +printf "%s\n" "$ECHO" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5764,11 +6353,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "mkdir", so it can be a program name with args. set dummy mkdir; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_MKDIR+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_MKDIR+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$MKDIR"; then ac_cv_prog_MKDIR="$MKDIR" # Let the user override the test. else @@ -5776,11 +6366,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_MKDIR="mkdir -p" - $as_echo "$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 @@ -5791,11 +6385,11 @@ fi fi MKDIR=$ac_cv_prog_MKDIR if test -n "$MKDIR"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 -$as_echo "$MKDIR" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5 +printf "%s\n" "$MKDIR" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5811,11 +6405,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "touch", so it can be a program name with args. set dummy touch; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_TOUCH+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_TOUCH+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$TOUCH"; then ac_cv_prog_TOUCH="$TOUCH" # Let the user override the test. else @@ -5823,11 +6418,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_TOUCH="touch " - $as_echo "$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 @@ -5838,11 +6437,11 @@ fi fi TOUCH=$ac_cv_prog_TOUCH if test -n "$TOUCH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 -$as_echo "$TOUCH" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5 +printf "%s\n" "$TOUCH" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5858,11 +6457,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "sort", so it can be a program name with args. set dummy sort; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_SORT+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SORT+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$SORT"; then ac_cv_prog_SORT="$SORT" # Let the user override the test. else @@ -5870,11 +6470,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_SORT="sort " - $as_echo "$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 @@ -5885,11 +6489,11 @@ fi fi SORT=$ac_cv_prog_SORT if test -n "$SORT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 -$as_echo "$SORT" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5 +printf "%s\n" "$SORT" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5905,11 +6509,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "uniq", so it can be a program name with args. set dummy uniq; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_UNIQ+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_UNIQ+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$UNIQ"; then ac_cv_prog_UNIQ="$UNIQ" # Let the user override the test. else @@ -5917,11 +6522,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_UNIQ="uniq " - $as_echo "$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 @@ -5932,11 +6541,11 @@ fi fi UNIQ=$ac_cv_prog_UNIQ if test -n "$UNIQ"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5 -$as_echo "$UNIQ" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5 +printf "%s\n" "$UNIQ" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5952,11 +6561,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "true", so it can be a program name with args. set dummy true; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_NOP+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_NOP+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$NOP"; then ac_cv_prog_NOP="$NOP" # Let the user override the test. else @@ -5964,11 +6574,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_NOP="true " - $as_echo "$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 @@ -5979,11 +6593,11 @@ fi fi NOP=$ac_cv_prog_NOP if test -n "$NOP"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NOP" >&5 -$as_echo "$NOP" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NOP" >&5 +printf "%s\n" "$NOP" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -5999,11 +6613,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "cat", so it can be a program name with args. set dummy cat; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CAT+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CAT+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CAT"; then ac_cv_prog_CAT="$CAT" # Let the user override the test. else @@ -6011,11 +6626,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CAT="cat " - $as_echo "$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 @@ -6026,11 +6645,11 @@ fi fi CAT=$ac_cv_prog_CAT if test -n "$CAT"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 -$as_echo "$CAT" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5 +printf "%s\n" "$CAT" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6046,11 +6665,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "bison", so it can be a program name with args. set dummy bison; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_BISON+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_BISON+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$BISON"; then ac_cv_prog_BISON="$BISON" # Let the user override the test. else @@ -6058,11 +6678,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_BISON="bison " - $as_echo "$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 @@ -6073,11 +6697,11 @@ fi fi BISON=$ac_cv_prog_BISON if test -n "$BISON"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5 -$as_echo "$BISON" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BISON" >&5 +printf "%s\n" "$BISON" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6093,11 +6717,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "flex", so it can be a program name with args. set dummy flex; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_FLEX+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_FLEX+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$FLEX"; then ac_cv_prog_FLEX="$FLEX" # Let the user override the test. else @@ -6105,11 +6730,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_FLEX="flex " - $as_echo "$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 @@ -6120,11 +6749,11 @@ fi fi FLEX=$ac_cv_prog_FLEX if test -n "$FLEX"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5 -$as_echo "$FLEX" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FLEX" >&5 +printf "%s\n" "$FLEX" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6138,18 +6767,19 @@ fi if test "$req_avail" = "no"; then as_fn_error $? "flex is required to build AROS. Please install and run configure again." "$LINENO" 5 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking version of $FLEX" >&5 -$as_echo_n "checking version of $FLEX... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking version of $FLEX" >&5 +printf %s "checking version of $FLEX... " >&6; } ax_cv_flex_version="`$FLEX --version | cut -d\" \" -f2`" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_flex_version" >&5 -$as_echo "$ax_cv_flex_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_flex_version" >&5 +printf "%s\n" "$ax_cv_flex_version" >&6; } # Extract the first word of "pngtopnm", so it can be a program name with args. set dummy pngtopnm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PNGTOPNM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PNGTOPNM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PNGTOPNM"; then ac_cv_prog_PNGTOPNM="$PNGTOPNM" # Let the user override the test. else @@ -6157,11 +6787,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PNGTOPNM="pngtopnm " - $as_echo "$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 @@ -6172,11 +6806,11 @@ fi fi PNGTOPNM=$ac_cv_prog_PNGTOPNM if test -n "$PNGTOPNM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PNGTOPNM" >&5 -$as_echo "$PNGTOPNM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PNGTOPNM" >&5 +printf "%s\n" "$PNGTOPNM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6192,11 +6826,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "ppmtoilbm", so it can be a program name with args. set dummy ppmtoilbm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PPMTOILBM+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PPMTOILBM+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PPMTOILBM"; then ac_cv_prog_PPMTOILBM="$PPMTOILBM" # Let the user override the test. else @@ -6204,11 +6839,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PPMTOILBM="ppmtoilbm " - $as_echo "$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 @@ -6219,11 +6858,11 @@ fi fi PPMTOILBM=$ac_cv_prog_PPMTOILBM if test -n "$PPMTOILBM"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PPMTOILBM" >&5 -$as_echo "$PPMTOILBM" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PPMTOILBM" >&5 +printf "%s\n" "$PPMTOILBM" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6239,11 +6878,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "sed", so it can be a program name with args. set dummy sed; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_SED+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SED+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$SED"; then ac_cv_prog_SED="$SED" # Let the user override the test. else @@ -6251,11 +6891,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_SED="sed " - $as_echo "$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 @@ -6266,11 +6910,11 @@ fi fi SED=$ac_cv_prog_SED if test -n "$SED"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 -$as_echo "$SED" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5 +printf "%s\n" "$SED" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6286,11 +6930,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "chmod", so it can be a program name with args. set dummy chmod; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CHMOD+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CHMOD+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CHMOD"; then ac_cv_prog_CHMOD="$CHMOD" # Let the user override the test. else @@ -6298,11 +6943,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CHMOD="chmod " - $as_echo "$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 @@ -6313,11 +6962,11 @@ fi fi CHMOD=$ac_cv_prog_CHMOD if test -n "$CHMOD"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 -$as_echo "$CHMOD" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5 +printf "%s\n" "$CHMOD" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6333,11 +6982,12 @@ if test "$req_avail" = "no"; then fi # Extract the first word of "patch", so it can be a program name with args. set dummy patch; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_PATCH+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PATCH+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$PATCH"; then ac_cv_prog_PATCH="$PATCH" # Let the user override the test. else @@ -6345,11 +6995,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_PATCH="patch " - $as_echo "$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 @@ -6360,11 +7014,11 @@ fi fi PATCH=$ac_cv_prog_PATCH if test -n "$PATCH"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5 -$as_echo "$PATCH" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PATCH" >&5 +printf "%s\n" "$PATCH" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6387,8 +7041,8 @@ fi if test -n "$PYTHON"; then # If the user set $PYTHON, use it and don't search something else. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 3.0" >&5 -$as_echo_n "checking whether $PYTHON version is >= 3.0... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 3.0" >&5 +printf %s "checking whether $PYTHON version is >= 3.0... " >&6; } prog="import sys # split strings by '.' and convert to numeric. Append some zeros # because we need at least 4 digits for the hex conversion. @@ -6402,25 +7056,27 @@ sys.exit(sys.hexversion < minverhex)" ($PYTHON -c "$prog") >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then : - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + (exit $ac_status); } +then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } +else $as_nop + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } as_fn_error $? "Python interpreter is too old" "$LINENO" 5 fi am_display_PYTHON=$PYTHON else # Otherwise, try each interpreter until we find one that satisfies # VERSION. - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 3.0" >&5 -$as_echo_n "checking for a Python interpreter with version >= 3.0... " >&6; } -if ${am_cv_pathless_PYTHON+:} false; then : - $as_echo_n "(cached) " >&6 -else - - for am_cv_pathless_PYTHON in python python2 python3 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 3.0" >&5 +printf %s "checking for a Python interpreter with version >= 3.0... " >&6; } +if test ${am_cv_pathless_PYTHON+y} +then : + printf %s "(cached) " >&6 +else $as_nop + + for am_cv_pathless_PYTHON in python python2 python3 python3.11 python3.10 python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 python3.2 python3.1 python3.0 python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0 none; do test "$am_cv_pathless_PYTHON" = none && break prog="import sys # split strings by '.' and convert to numeric. Append some zeros @@ -6435,24 +7091,26 @@ sys.exit(sys.hexversion < minverhex)" ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5 ac_status=$? echo "$as_me:$LINENO: \$? = $ac_status" >&5 - (exit $ac_status); }; then : + (exit $ac_status); } +then : break fi done fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 -$as_echo "$am_cv_pathless_PYTHON" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5 +printf "%s\n" "$am_cv_pathless_PYTHON" >&6; } # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON. if test "$am_cv_pathless_PYTHON" = none; then PYTHON=: else # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args. set dummy $am_cv_pathless_PYTHON; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_PYTHON+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_PYTHON+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $PYTHON in [\\/]* | ?:[\\/]*) ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path. @@ -6462,11 +7120,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_PYTHON="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_PYTHON="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -6478,11 +7140,11 @@ esac fi PYTHON=$ac_cv_path_PYTHON if test -n "$PYTHON"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 -$as_echo "$PYTHON" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5 +printf "%s\n" "$PYTHON" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -6492,42 +7154,172 @@ fi if test "$PYTHON" = :; then - as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 + as_fn_error $? "no suitable Python interpreter found" "$LINENO" 5 else - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 -$as_echo_n "checking for $am_display_PYTHON version... " >&6; } -if ${am_cv_python_version+:} false; then : - $as_echo_n "(cached) " >&6 -else - am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[:3])"` + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5 +printf %s "checking for $am_display_PYTHON version... " >&6; } +if test ${am_cv_python_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_version=`$PYTHON -c "import sys; print ('%u.%u' % sys.version_info[:2])"` fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 -$as_echo "$am_cv_python_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5 +printf "%s\n" "$am_cv_python_version" >&6; } PYTHON_VERSION=$am_cv_python_version + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 +printf %s "checking for $am_display_PYTHON platform... " >&6; } +if test ${am_cv_python_platform+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 +printf "%s\n" "$am_cv_python_platform" >&6; } + PYTHON_PLATFORM=$am_cv_python_platform - PYTHON_PREFIX='${prefix}' - - PYTHON_EXEC_PREFIX='${exec_prefix}' + if test "x$prefix" = xNONE; then + am__usable_prefix=$ac_default_prefix + else + am__usable_prefix=$prefix + fi + # Allow user to request using sys.* values from Python, + # instead of the GNU $prefix values. + +# Check whether --with-python-sys-prefix was given. +if test ${with_python_sys_prefix+y} +then : + withval=$with_python_sys_prefix; am_use_python_sys=: +else $as_nop + am_use_python_sys=false +fi + + + # Allow user to override whatever the default Python prefix is. + +# Check whether --with-python_prefix was given. +if test ${with_python_prefix+y} +then : + withval=$with_python_prefix; am_python_prefix_subst=$withval + am_cv_python_prefix=$withval + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for explicit $am_display_PYTHON prefix" >&5 +printf %s "checking for explicit $am_display_PYTHON prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_prefix" >&5 +printf "%s\n" "$am_cv_python_prefix" >&6; } +else $as_nop + + if $am_use_python_sys; then + # using python sys.prefix value, not GNU + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python default $am_display_PYTHON prefix" >&5 +printf %s "checking for python default $am_display_PYTHON prefix... " >&6; } +if test ${am_cv_python_prefix+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.prefix)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_prefix" >&5 +printf "%s\n" "$am_cv_python_prefix" >&6; } + + case $am_cv_python_prefix in + $am__usable_prefix*) + am__strip_prefix=`echo "$am__usable_prefix" | sed 's|.|.|g'` + am_python_prefix_subst=`echo "$am_cv_python_prefix" | sed "s,^$am__strip_prefix,\\${prefix},"` + ;; + *) + am_python_prefix_subst=$am_cv_python_prefix + ;; + esac + else # using GNU prefix value, not python sys.prefix + am_python_prefix_subst='${prefix}' + am_python_prefix=$am_python_prefix_subst + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU default $am_display_PYTHON prefix" >&5 +printf %s "checking for GNU default $am_display_PYTHON prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_python_prefix" >&5 +printf "%s\n" "$am_python_prefix" >&6; } + fi +fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5 -$as_echo_n "checking for $am_display_PYTHON platform... " >&6; } -if ${am_cv_python_platform+:} false; then : - $as_echo_n "(cached) " >&6 -else - am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"` + # Substituting python_prefix_subst value. + PYTHON_PREFIX=$am_python_prefix_subst + + + # emacs-page Now do it all over again for Python exec_prefix, but with yet + # another conditional: fall back to regular prefix if that was specified. + +# Check whether --with-python_exec_prefix was given. +if test ${with_python_exec_prefix+y} +then : + withval=$with_python_exec_prefix; am_python_exec_prefix_subst=$withval + am_cv_python_exec_prefix=$withval + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for explicit $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for explicit $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } +else $as_nop + + # no explicit --with-python_exec_prefix, but if + # --with-python_prefix was given, use its value for python_exec_prefix too. + if test -n "$with_python_prefix" +then : + am_python_exec_prefix_subst=$with_python_prefix + am_cv_python_exec_prefix=$with_python_prefix + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python_prefix-given $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for python_prefix-given $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } +else $as_nop + + # Set am__usable_exec_prefix whether using GNU or Python values, + # since we use that variable for pyexecdir. + if test "x$exec_prefix" = xNONE; then + am__usable_exec_prefix=$am__usable_prefix + else + am__usable_exec_prefix=$exec_prefix + fi + # + if $am_use_python_sys; then # using python sys.exec_prefix, not GNU + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for python default $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for python default $am_display_PYTHON exec_prefix... " >&6; } +if test ${am_cv_python_exec_prefix+y} +then : + printf %s "(cached) " >&6 +else $as_nop + am_cv_python_exec_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)"` +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_exec_prefix" >&5 +printf "%s\n" "$am_cv_python_exec_prefix" >&6; } + case $am_cv_python_exec_prefix in + $am__usable_exec_prefix*) + am__strip_prefix=`echo "$am__usable_exec_prefix" | sed 's|.|.|g'` + am_python_exec_prefix_subst=`echo "$am_cv_python_exec_prefix" | sed "s,^$am__strip_prefix,\\${exec_prefix},"` + ;; + *) + am_python_exec_prefix_subst=$am_cv_python_exec_prefix + ;; + esac + else # using GNU $exec_prefix, not python sys.exec_prefix + am_python_exec_prefix_subst='${exec_prefix}' + am_python_exec_prefix=$am_python_exec_prefix_subst + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU default $am_display_PYTHON exec_prefix" >&5 +printf %s "checking for GNU default $am_display_PYTHON exec_prefix... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_python_exec_prefix" >&5 +printf "%s\n" "$am_python_exec_prefix" >&6; } + fi +fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5 -$as_echo "$am_cv_python_platform" >&6; } - PYTHON_PLATFORM=$am_cv_python_platform + # Substituting python_exec_prefix_subst. + PYTHON_EXEC_PREFIX=$am_python_exec_prefix_subst - # Just factor out some code duplication. + + # Factor out some code duplication into this shell variable. am_python_setup_sysconfig="\ import sys # Prefer sysconfig over distutils.sysconfig, for better compatibility @@ -6548,534 +7340,352 @@ except ImportError: pass" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5 -$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; } -if ${am_cv_python_pythondir+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "x$prefix" = xNONE - then - am_py_prefix=$ac_default_prefix - else - am_py_prefix=$prefix - fi - am_cv_python_pythondir=`$PYTHON -c " + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory (pythondir)" >&5 +printf %s "checking for $am_display_PYTHON script directory (pythondir)... " >&6; } +if test ${am_cv_python_pythondir+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "x$am_cv_python_prefix" = x; then + am_py_prefix=$am__usable_prefix + else + am_py_prefix=$am_cv_python_prefix + fi + am_cv_python_pythondir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('purelib', scheme, vars={'base':'$am_py_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pythondir in - $am_py_prefix*) - am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` - am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"` - ;; - *) - case $am_py_prefix in - /usr|/System*) ;; - *) - am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pythondir in + $am_py_prefix*) + am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'` + am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,\\${PYTHON_PREFIX},"` + ;; + *) + case $am_py_prefix in + /usr|/System*) ;; + *) am_cv_python_pythondir="\${PYTHON_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac + ;; + esac fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 -$as_echo "$am_cv_python_pythondir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5 +printf "%s\n" "$am_cv_python_pythondir" >&6; } pythondir=$am_cv_python_pythondir + pkgpythondir=\${pythondir}/$PACKAGE - pkgpythondir=\${pythondir}/$PACKAGE - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5 -$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; } -if ${am_cv_python_pyexecdir+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "x$exec_prefix" = xNONE - then - am_py_exec_prefix=$am_py_prefix - else - am_py_exec_prefix=$exec_prefix - fi - am_cv_python_pyexecdir=`$PYTHON -c " + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory (pyexecdir)" >&5 +printf %s "checking for $am_display_PYTHON extension module directory (pyexecdir)... " >&6; } +if test ${am_cv_python_pyexecdir+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "x$am_cv_python_exec_prefix" = x; then + am_py_exec_prefix=$am__usable_exec_prefix + else + am_py_exec_prefix=$am_cv_python_exec_prefix + fi + am_cv_python_pyexecdir=`$PYTHON -c " $am_python_setup_sysconfig if can_use_sysconfig: - sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'}) + if hasattr(sysconfig, 'get_default_scheme'): + scheme = sysconfig.get_default_scheme() + else: + scheme = sysconfig._get_default_scheme() + if scheme == 'posix_local': + # Debian's default scheme installs to /usr/local/ but we want to find headers in /usr/ + scheme = 'posix_prefix' + sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase':'$am_py_exec_prefix'}) else: - from distutils import sysconfig - sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix') + from distutils import sysconfig + sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_exec_prefix') sys.stdout.write(sitedir)"` - case $am_cv_python_pyexecdir in - $am_py_exec_prefix*) - am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` - am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"` - ;; - *) - case $am_py_exec_prefix in - /usr|/System*) ;; - *) - am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages - ;; - esac - ;; + # + case $am_cv_python_pyexecdir in + $am_py_exec_prefix*) + am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'` + am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,\\${PYTHON_EXEC_PREFIX},"` + ;; + *) + case $am_py_exec_prefix in + /usr|/System*) ;; + *) am_cv_python_pyexecdir="\${PYTHON_EXEC_PREFIX}/lib/python$PYTHON_VERSION/site-packages" + ;; esac + ;; + esac fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 -$as_echo "$am_cv_python_pyexecdir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5 +printf "%s\n" "$am_cv_python_pyexecdir" >&6; } pyexecdir=$am_cv_python_pyexecdir - - pkgpyexecdir=\${pyexecdir}/$PACKAGE + pkgpyexecdir=\${pyexecdir}/$PACKAGE fi - # Check whether --enable-libpng-config was given. -if test "${enable_libpng_config+set}" = set; then : +if test ${enable_libpng_config+y} +then : enableval=$enable_libpng_config; fi if test "$enable_libpng_config" != "no"; then # Extract the first word of "libpng-config", so it can be a program name with args. set dummy libpng-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_arosconfig_use_libpngconfig+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_arosconfig_use_libpngconfig+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$arosconfig_use_libpngconfig"; then ac_cv_prog_arosconfig_use_libpngconfig="$arosconfig_use_libpngconfig" # Let the user override the test. -else -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - 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_arosconfig_use_libpngconfig="yes" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done - done -IFS=$as_save_IFS - - test -z "$ac_cv_prog_arosconfig_use_libpngconfig" && ac_cv_prog_arosconfig_use_libpngconfig="no" -fi -fi -arosconfig_use_libpngconfig=$ac_cv_prog_arosconfig_use_libpngconfig -if test -n "$arosconfig_use_libpngconfig"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $arosconfig_use_libpngconfig" >&5 -$as_echo "$arosconfig_use_libpngconfig" >&6; } -else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } -fi - - -fi -if test "$arosconfig_use_libpngconfig" = "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking libpng-config library" >&5 -$as_echo_n "checking libpng-config library... " >&6; } - libpng_incdir="`libpng-config --cflags`" - libpng_libextra="$libpng_libextra `libpng-config --ldflags`" - libpng="`libpng-config --libs`" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $libpng" >&5 -$as_echo "$libpng" >&6; } -else - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for png_read_png in -lpng" >&5 -$as_echo_n "checking for png_read_png in -lpng... " >&6; } -if ${ac_cv_lib_png_png_read_png+:} false; then : - $as_echo_n "(cached) " >&6 -else - ac_check_lib_save_LIBS=$LIBS -LIBS="-lpng $LIBS" -cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ - -/* Override any GCC internal prototype to avoid an error. - Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif -char png_read_png (); -int -main () -{ -return png_read_png (); - ; - return 0; -} -_ACEOF -if ac_fn_c_try_link "$LINENO"; then : - ac_cv_lib_png_png_read_png=yes -else - ac_cv_lib_png_png_read_png=no -fi -rm -f core conftest.err conftest.$ac_objext \ - conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_png_png_read_png" >&5 -$as_echo "$ac_cv_lib_png_png_read_png" >&6; } -if test "x$ac_cv_lib_png_png_read_png" = xyes; then : - libpng="-lpng" -else - libpng="no" -fi - - if test "$libpng_libextra" != ""; then - if test "$libpng" != "no"; then - libpng_libextra="$libpng_libextra $libpng" - fi - fi -fi -req_avail=yes -if test "$libpng" = ""; then - req_avail=no -fi -if test "$libpng" = "no"; then - req_avail=no -fi -if test "$req_avail" = "no"; then - as_fn_error $? "libpng is required to build AROS. Please install and run configure again." "$LINENO" 5 -fi - - - - -FOR=for - -IF=if - -TEST=test - -CMP=cmp - - - -# Check for some includes for the X11 HIDD and the kernel - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 -$as_echo_n "checking for grep that handles long lines and -e... " >&6; } -if ${ac_cv_path_GREP+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test -z "$GREP"; then - ac_path_GREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in grep ggrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" - as_fn_executable_p "$ac_path_GREP" || continue -# Check for GNU ac_path_GREP and select it if it is found. - # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in -*GNU*) - ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo '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 - if test $ac_count -gt ${ac_path_GREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_GREP="$ac_path_GREP" - ac_path_GREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_GREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_GREP"; then - as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_GREP=$GREP -fi - -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 -$as_echo "$ac_cv_path_GREP" >&6; } - GREP="$ac_cv_path_GREP" - - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 -$as_echo_n "checking for egrep... " >&6; } -if ${ac_cv_path_EGREP+:} false; then : - $as_echo_n "(cached) " >&6 -else - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 - then ac_cv_path_EGREP="$GREP -E" - else - if test -z "$EGREP"; then - ac_path_EGREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_prog in egrep; do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" - as_fn_executable_p "$ac_path_EGREP" || continue -# Check for GNU ac_path_EGREP and select it if it is found. - # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in -*GNU*) - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; -*) - ac_count=0 - $as_echo_n 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - $as_echo '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 - if test $ac_count -gt ${ac_path_EGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_EGREP="$ac_path_EGREP" - ac_path_EGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_EGREP_found && break 3 - done - done +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + 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_arosconfig_use_libpngconfig="yes" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 + break 2 + fi +done done IFS=$as_save_IFS - if test -z "$ac_cv_path_EGREP"; then - as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_EGREP=$EGREP -fi - fi + test -z "$ac_cv_prog_arosconfig_use_libpngconfig" && ac_cv_prog_arosconfig_use_libpngconfig="no" +fi +fi +arosconfig_use_libpngconfig=$ac_cv_prog_arosconfig_use_libpngconfig +if test -n "$arosconfig_use_libpngconfig"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $arosconfig_use_libpngconfig" >&5 +printf "%s\n" "$arosconfig_use_libpngconfig" >&6; } +else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -$as_echo "$ac_cv_path_EGREP" >&6; } - EGREP="$ac_cv_path_EGREP" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 -$as_echo_n "checking for ANSI C header files... " >&6; } -if ${ac_cv_header_stdc+:} false; then : - $as_echo_n "(cached) " >&6 +fi +if test "$arosconfig_use_libpngconfig" = "yes"; then + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking libpng-config library" >&5 +printf %s "checking libpng-config library... " >&6; } + libpng_incdir="`libpng-config --cflags`" + libpng_libextra="$libpng_libextra `libpng-config --ldflags`" + libpng="`libpng-config --libs`" + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $libpng" >&5 +printf "%s\n" "$libpng" >&6; } else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for png_read_png in -lpng" >&5 +printf %s "checking for png_read_png in -lpng... " >&6; } +if test ${ac_cv_lib_png_png_read_png+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_check_lib_save_LIBS=$LIBS +LIBS="-lpng $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ -#include -#include -#include -#include +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +char png_read_png (); int -main () +main (void) { - +return png_read_png (); ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_stdc=yes -else - ac_cv_header_stdc=no +if ac_fn_c_try_link "$LINENO" +then : + ac_cv_lib_png_png_read_png=yes +else $as_nop + ac_cv_lib_png_png_read_png=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_png_png_read_png" >&5 +printf "%s\n" "$ac_cv_lib_png_png_read_png" >&6; } +if test "x$ac_cv_lib_png_png_read_png" = xyes +then : + libpng="-lpng" +else $as_nop + libpng="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include + if test "$libpng_libextra" != ""; then + if test "$libpng" != "no"; then + libpng_libextra="$libpng_libextra $libpng" + fi + fi +fi +req_avail=yes +if test "$libpng" = ""; then + req_avail=no +fi +if test "$libpng" = "no"; then + req_avail=no +fi +if test "$req_avail" = "no"; then + as_fn_error $? "libpng is required to build AROS. Please install and run configure again." "$LINENO" 5 +fi -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then : -else - ac_cv_header_stdc=no -fi -rm -f conftest* -fi -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include +FOR=for + +IF=if + +TEST=test + +CMP=cmp + + + +# Check for some includes for the X11 HIDD and the kernel +ac_header= ac_cache= +for ac_item in $ac_header_c_list +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 + fi + ac_header= ac_cache= + elif test $ac_header; then + ac_cache=$ac_item + else + ac_header=$ac_item + fi +done -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then : -else - ac_cv_header_stdc=no -fi -rm -f conftest* -fi -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then : - : -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -if ac_fn_c_try_run "$LINENO"; then : -else - ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext -fi -fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 -$as_echo "$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then -$as_echo "#define STDC_HEADERS 1" >>confdefs.h +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 fi +ac_fn_c_check_header_compile "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ipc_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_IPC_H 1" >>confdefs.h -# On IRIX 5.3, sys/types and inttypes.h are conflicting. -for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ - inttypes.h stdint.h unistd.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default -" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_header_compile "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_shm_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_SHM_H 1" >>confdefs.h fi +ac_fn_c_check_header_compile "$LINENO" "sys/mmap.h" "ac_cv_header_sys_mmap_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_mmap_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MMAP_H 1" >>confdefs.h -done +fi +ac_fn_c_check_header_compile "$LINENO" "sys/mman.h" "ac_cv_header_sys_mman_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_mman_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MMAN_H 1" >>confdefs.h +fi +ac_fn_c_check_header_compile "$LINENO" "sysexits.h" "ac_cv_header_sysexits_h" "$ac_includes_default" +if test "x$ac_cv_header_sysexits_h" = xyes +then : + printf "%s\n" "#define HAVE_SYSEXITS_H 1" >>confdefs.h -for ac_header in sys/ipc.h sys/shm.h \ - sys/mmap.h sys/mman.h sysexits.h \ - sys/statfs.h sys/statvfs.h sys/vfs.h sys/param.h \ +fi +ac_fn_c_check_header_compile "$LINENO" "sys/statfs.h" "ac_cv_header_sys_statfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_statfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_STATFS_H 1" >>confdefs.h -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_header_compile "$LINENO" "sys/statvfs.h" "ac_cv_header_sys_statvfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_statvfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_STATVFS_H 1" >>confdefs.h fi +ac_fn_c_check_header_compile "$LINENO" "sys/vfs.h" "ac_cv_header_sys_vfs_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_vfs_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_VFS_H 1" >>confdefs.h -done +fi +ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_param_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h +fi -for ac_header in sys/mount.h -do : - ac_fn_c_check_header_compile "$LINENO" "sys/mount.h" "ac_cv_header_sys_mount_h" "#include + +ac_fn_c_check_header_compile "$LINENO" "sys/mount.h" "ac_cv_header_sys_mount_h" "#include " -if test "x$ac_cv_header_sys_mount_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_MOUNT_H 1 -_ACEOF +if test "x$ac_cv_header_sys_mount_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_MOUNT_H 1" >>confdefs.h fi -done - -for ac_header in GL/glx.h + for ac_header in GL/glx.h do : - ac_fn_c_check_header_mongrel "$LINENO" "GL/glx.h" "ac_cv_header_GL_glx_h" "$ac_includes_default" -if test "x$ac_cv_header_GL_glx_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_GL_GLX_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "GL/glx.h" "ac_cv_header_GL_glx_h" "$ac_includes_default" +if test "x$ac_cv_header_GL_glx_h" = xyes +then : + printf "%s\n" "#define HAVE_GL_GLX_H 1" >>confdefs.h host_feature_glx=yes -else +else $as_nop host_feature_glx=no fi done - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if __unused conflicts with sys/stat.h" >&5 -$as_echo_n "checking if __unused conflicts with sys/stat.h... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if __unused conflicts with sys/stat.h" >&5 +printf %s "checking if __unused conflicts with sys/stat.h... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7083,37 +7693,39 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext #include int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : host_stat_h__unused_used=no -else +else $as_nop host_stat_h__unused_used=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $host_stat_h__unused_used" >&5 -$as_echo "$host_stat_h__unused_used" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $host_stat_h__unused_used" >&5 +printf "%s\n" "$host_stat_h__unused_used" >&6; } ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do - as_ac_Header=`$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 -$as_echo_n "checking for $ac_hdr that defines DIR... " >&6; } -if eval \${$as_ac_Header+:} false; then : - $as_echo_n "(cached) " >&6 -else + as_ac_Header=`printf "%s\n" "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 +printf %s "checking for $ac_hdr that defines DIR... " >&6; } +if eval test \${$as_ac_Header+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include <$ac_hdr> int -main () +main (void) { if ((DIR *) 0) return 0; @@ -7121,19 +7733,21 @@ return 0; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : eval "$as_ac_Header=yes" -else +else $as_nop eval "$as_ac_Header=no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi eval ac_res=\$$as_ac_Header - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 -$as_echo "$ac_res" >&6; } -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +printf "%s\n" "$ac_res" >&6; } +if eval test \"x\$"$as_ac_Header"\" = x"yes" +then : cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 +#define `printf "%s\n" "HAVE_$ac_hdr" | $as_tr_cpp` 1 _ACEOF ac_header_dirent=$ac_hdr; break @@ -7142,11 +7756,12 @@ fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 -$as_echo_n "checking for library containing opendir... " >&6; } -if ${ac_cv_search_opendir+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +printf %s "checking for library containing opendir... " >&6; } +if test ${ac_cv_search_opendir+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7154,56 +7769,59 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char opendir (); int -main () +main (void) { return opendir (); ; return 0; } _ACEOF -for ac_lib in '' dir; do +for ac_lib in '' dir +do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi - if ac_fn_c_try_link "$LINENO"; then : + if ac_fn_c_try_link "$LINENO" +then : ac_cv_search_opendir=$ac_res fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext - if ${ac_cv_search_opendir+:} false; then : + if test ${ac_cv_search_opendir+y} +then : break fi done -if ${ac_cv_search_opendir+:} false; then : +if test ${ac_cv_search_opendir+y} +then : -else +else $as_nop ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -$as_echo "$ac_cv_search_opendir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf "%s\n" "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir -if test "$ac_res" != no; then : +if test "$ac_res" != no +then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 -$as_echo_n "checking for library containing opendir... " >&6; } -if ${ac_cv_search_opendir+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 +printf %s "checking for library containing opendir... " >&6; } +if test ${ac_cv_search_opendir+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -7211,57 +7829,60 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char opendir (); int -main () +main (void) { return opendir (); ; return 0; } _ACEOF -for ac_lib in '' x; do +for ac_lib in '' x +do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi - if ac_fn_c_try_link "$LINENO"; then : + if ac_fn_c_try_link "$LINENO" +then : ac_cv_search_opendir=$ac_res fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext - if ${ac_cv_search_opendir+:} false; then : + if test ${ac_cv_search_opendir+y} +then : break fi done -if ${ac_cv_search_opendir+:} false; then : +if test ${ac_cv_search_opendir+y} +then : -else +else $as_nop ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 -$as_echo "$ac_cv_search_opendir" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 +printf "%s\n" "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir -if test "$ac_res" != no; then : +if test "$ac_res" != no +then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 -$as_echo_n "checking whether stat file-mode macros are broken... " >&6; } -if ${ac_cv_header_stat_broken+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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 : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7284,138 +7905,174 @@ extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; #endif _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_header_stat_broken=no -else +else $as_nop ac_cv_header_stat_broken=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 -$as_echo "$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 -$as_echo "#define STAT_MACROS_BROKEN 1" >>confdefs.h - -fi - -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 -$as_echo_n "checking for ANSI C header files... " >&6; } -if ${ac_cv_header_stdc+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -#include - -int -main () -{ +printf "%s\n" "#define STAT_MACROS_BROKEN 1" >>confdefs.h - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_stdc=yes -else - ac_cv_header_stdc=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext - -if test $ac_cv_header_stdc = yes; then - # SunOS 4.x string.h does not declare mem*, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "memchr" >/dev/null 2>&1; then : +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_prog in grep ggrep + do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + printf %s 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "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 + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi else - ac_cv_header_stdc=no -fi -rm -f conftest* - + ac_cv_path_GREP=$GREP fi -if test $ac_cv_header_stdc = yes; then - # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "free" >/dev/null 2>&1; then : - -else - ac_cv_header_stdc=no fi -rm -f conftest* +{ 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" -fi -if test $ac_cv_header_stdc = yes; then - # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. - if test "$cross_compiling" = yes; then : - : -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#if ((' ' & 0x0FF) == 0x020) -# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') -# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) -#else -# define ISLOWER(c) \ - (('a' <= (c) && (c) <= 'i') \ - || ('j' <= (c) && (c) <= 'r') \ - || ('s' <= (c) && (c) <= 'z')) -# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) -#endif +# Autoupdate added the next two lines to ensure that your configure +# script's behavior did not change. They are probably safe to remove. -#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) -int -main () -{ - int i; - for (i = 0; i < 256; i++) - if (XOR (islower (i), ISLOWER (i)) - || toupper (i) != TOUPPER (i)) - return 2; - return 0; -} -_ACEOF -if ac_fn_c_try_run "$LINENO"; then : +{ 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 : + printf %s "(cached) " >&6 +else $as_nop + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + for ac_prog in egrep + do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + printf %s 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "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 + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi else - ac_cv_header_stdc=no -fi -rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext + ac_cv_path_EGREP=$EGREP fi + fi fi -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 -$as_echo "$ac_cv_header_stdc" >&6; } -if test $ac_cv_header_stdc = yes; then +{ 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" -$as_echo "#define STDC_HEADERS 1" >>confdefs.h -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 -$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } -if ${ac_cv_header_sys_wait_h+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 +printf %s "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } +if test ${ac_cv_header_sys_wait_h+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7428,7 +8085,7 @@ else #endif int -main () +main (void) { int s; wait (&s); @@ -7437,80 +8094,54 @@ main () return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_header_sys_wait_h=yes -else +else $as_nop ac_cv_header_sys_wait_h=no fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 -$as_echo "$ac_cv_header_sys_wait_h" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 +printf "%s\n" "$ac_cv_header_sys_wait_h" >&6; } if test $ac_cv_header_sys_wait_h = yes; then -$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h +printf "%s\n" "#define HAVE_SYS_WAIT_H 1" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5 -$as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; } -if ${ac_cv_header_time+:} false; then : - $as_echo_n "(cached) " >&6 -else - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -#include -#include -int -main () -{ -if ((struct tm *) 0) -return 0; - ; - return 0; -} -_ACEOF -if ac_fn_c_try_compile "$LINENO"; then : - ac_cv_header_time=yes -else - ac_cv_header_time=no -fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5 -$as_echo "$ac_cv_header_time" >&6; } -if test $ac_cv_header_time = yes; then -$as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h +# Obsolete code to be removed. +if test $ac_cv_header_sys_time_h = yes; then + +printf "%s\n" "#define TIME_WITH_SYS_TIME 1" >>confdefs.h fi +# End of obsolete code. ac_fn_c_check_member "$LINENO" "struct stat" "st_blksize" "ac_cv_member_struct_stat_st_blksize" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_blksize" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_blksize" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_BLKSIZE 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_BLKSIZE 1" >>confdefs.h -$as_echo "#define HAVE_ST_BLKSIZE 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_BLKSIZE 1" >>confdefs.h fi ac_fn_c_check_member "$LINENO" "struct stat" "st_blocks" "ac_cv_member_struct_stat_st_blocks" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_blocks" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_blocks" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_BLOCKS 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_BLOCKS 1" >>confdefs.h -$as_echo "#define HAVE_ST_BLOCKS 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_BLOCKS 1" >>confdefs.h -else +else $as_nop case " $LIBOBJS " in *" fileblocks.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS fileblocks.$ac_objext" @@ -7521,30 +8152,30 @@ fi ac_fn_c_check_member "$LINENO" "struct stat" "st_rdev" "ac_cv_member_struct_stat_st_rdev" "$ac_includes_default" -if test "x$ac_cv_member_struct_stat_st_rdev" = xyes; then : +if test "x$ac_cv_member_struct_stat_st_rdev" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_STAT_ST_RDEV 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_STAT_ST_RDEV 1" >>confdefs.h -$as_echo "#define HAVE_ST_RDEV 1" >>confdefs.h +printf "%s\n" "#define HAVE_ST_RDEV 1" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 -$as_echo_n "checking whether struct tm is in sys/time.h or time.h... " >&6; } -if ${ac_cv_struct_tm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether struct tm is in sys/time.h or time.h" >&5 +printf %s "checking whether struct tm is in sys/time.h or time.h... " >&6; } +if test ${ac_cv_struct_tm+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int -main () +main (void) { struct tm tm; int *p = &tm.tm_sec; @@ -7553,56 +8184,135 @@ struct tm tm; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : ac_cv_struct_tm=time.h -else +else $as_nop ac_cv_struct_tm=sys/time.h fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 -$as_echo "$ac_cv_struct_tm" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_struct_tm" >&5 +printf "%s\n" "$ac_cv_struct_tm" >&6; } if test $ac_cv_struct_tm = sys/time.h; then -$as_echo "#define TM_IN_SYS_TIME 1" >>confdefs.h +printf "%s\n" "#define TM_IN_SYS_TIME 1" >>confdefs.h + +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; } +if test ${ac_cv_c_undeclared_builtin_options+y} +then : + printf %s "(cached) " >&6 +else $as_nop + ac_save_CFLAGS=$CFLAGS + ac_cv_c_undeclared_builtin_options='cannot detect' + for ac_arg in '' -fno-builtin; do + CFLAGS="$ac_save_CFLAGS $ac_arg" + # This test program should *not* compile successfully. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main (void) +{ +(void) strchr; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + +else $as_nop + # This test program should compile successfully. + # No library function is consistently available on + # freestanding implementations, so test against a dummy + # declaration. Include always-available headers on the + # off chance that they somehow elicit warnings. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include +extern void ac_decl (int, char *); + +int +main (void) +{ +(void) ac_decl (0, (char *) 0); + (void) ac_decl; + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + if test x"$ac_arg" = x +then : + ac_cv_c_undeclared_builtin_options='none needed' +else $as_nop + ac_cv_c_undeclared_builtin_options=$ac_arg +fi + break +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext + done + CFLAGS=$ac_save_CFLAGS + +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; } + 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;} +as_fn_error $? "cannot make $CC report undeclared builtins +See \`config.log' for more details" "$LINENO" 5; } ;; #( + 'none needed') : + ac_c_undeclared_builtin_options='' ;; #( + *) : + ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;; +esac ac_fn_c_check_member "$LINENO" "struct tm" "tm_zone" "ac_cv_member_struct_tm_tm_zone" "#include #include <$ac_cv_struct_tm> " -if test "x$ac_cv_member_struct_tm_tm_zone" = xyes; then : +if test "x$ac_cv_member_struct_tm_tm_zone" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_TM_TM_ZONE 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_TM_TM_ZONE 1" >>confdefs.h fi if test "$ac_cv_member_struct_tm_tm_zone" = yes; then -$as_echo "#define HAVE_TM_ZONE 1" >>confdefs.h +printf "%s\n" "#define HAVE_TM_ZONE 1" >>confdefs.h else - ac_fn_c_check_decl "$LINENO" "tzname" "ac_cv_have_decl_tzname" "#include -" -if test "x$ac_cv_have_decl_tzname" = xyes; then : + ac_fn_check_decl "$LINENO" "tzname" "ac_cv_have_decl_tzname" "#include +" "$ac_c_undeclared_builtin_options" "CFLAGS" +if test "x$ac_cv_have_decl_tzname" = xyes +then : ac_have_decl=1 -else +else $as_nop ac_have_decl=0 fi +printf "%s\n" "#define HAVE_DECL_TZNAME $ac_have_decl" >>confdefs.h -cat >>confdefs.h <<_ACEOF -#define HAVE_DECL_TZNAME $ac_have_decl -_ACEOF - - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tzname" >&5 -$as_echo_n "checking for tzname... " >&6; } -if ${ac_cv_var_tzname+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for tzname" >&5 +printf %s "checking for tzname... " >&6; } +if test ${ac_cv_var_tzname+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include @@ -7611,164 +8321,250 @@ extern char *tzname[]; #endif int -main () +main (void) { return tzname[0][0]; ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_var_tzname=yes -else +else $as_nop ac_cv_var_tzname=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_var_tzname" >&5 -$as_echo "$ac_cv_var_tzname" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_var_tzname" >&5 +printf "%s\n" "$ac_cv_var_tzname" >&6; } if test $ac_cv_var_tzname = yes; then -$as_echo "#define HAVE_TZNAME 1" >>confdefs.h +printf "%s\n" "#define HAVE_TZNAME 1" >>confdefs.h fi fi ac_fn_c_check_type "$LINENO" "off_t" "ac_cv_type_off_t" "$ac_includes_default" -if test "x$ac_cv_type_off_t" = xyes; then : +if test "x$ac_cv_type_off_t" = xyes +then : -else +else $as_nop -cat >>confdefs.h <<_ACEOF -#define off_t long int -_ACEOF +printf "%s\n" "#define off_t long int" >>confdefs.h fi -ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" -if test "x$ac_cv_type_pid_t" = xyes; then : -else + ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default +" +if test "x$ac_cv_type_pid_t" = xyes +then : + +else $as_nop + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + #if defined _WIN64 && !defined __CYGWIN__ + LLP64 + #endif + +int +main (void) +{ + + ; + return 0; +} -cat >>confdefs.h <<_ACEOF -#define pid_t int _ACEOF +if ac_fn_c_try_compile "$LINENO" +then : + ac_pid_type='int' +else $as_nop + ac_pid_type='__int64' +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 + fi + ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" -if test "x$ac_cv_type_size_t" = xyes; then : +if test "x$ac_cv_type_size_t" = xyes +then : -else +else $as_nop -cat >>confdefs.h <<_ACEOF -#define size_t unsigned int -_ACEOF +printf "%s\n" "#define size_t unsigned int" >>confdefs.h fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 -$as_echo_n "checking for uid_t in sys/types.h... " >&6; } -if ${ac_cv_type_uid_t+:} false; then : - $as_echo_n "(cached) " >&6 -else + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5 +printf %s "checking for uid_t in sys/types.h... " >&6; } +if test ${ac_cv_type_uid_t+y} +then : + printf %s "(cached) " >&6 +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "uid_t" >/dev/null 2>&1; then : + $EGREP "uid_t" >/dev/null 2>&1 +then : ac_cv_type_uid_t=yes -else +else $as_nop ac_cv_type_uid_t=no fi -rm -f conftest* +rm -rf conftest* fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 -$as_echo "$ac_cv_type_uid_t" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5 +printf "%s\n" "$ac_cv_type_uid_t" >&6; } if test $ac_cv_type_uid_t = no; then -$as_echo "#define uid_t int" >>confdefs.h +printf "%s\n" "#define uid_t int" >>confdefs.h -$as_echo "#define gid_t int" >>confdefs.h +printf "%s\n" "#define gid_t int" >>confdefs.h fi ac_fn_c_check_member "$LINENO" "struct tm" "tm_gmtoff" "ac_cv_member_struct_tm_tm_gmtoff" "$ac_includes_default" -if test "x$ac_cv_member_struct_tm_tm_gmtoff" = xyes; then : +if test "x$ac_cv_member_struct_tm_tm_gmtoff" = xyes +then : -cat >>confdefs.h <<_ACEOF -#define HAVE_STRUCT_TM_TM_GMTOFF 1 -_ACEOF +printf "%s\n" "#define HAVE_STRUCT_TM_TM_GMTOFF 1" >>confdefs.h fi # Look for some functions -for ac_func in getpagesize kqueue statfs statvfs \ - clone kse_create rfork_thread thr_create sa_register \ - getcontext makecontext setcontext sigaltstack swapcontext -do : - as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` -ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" -if eval test \"x\$"$as_ac_var"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 -_ACEOF +ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" +if test "x$ac_cv_func_getpagesize" = xyes +then : + printf "%s\n" "#define HAVE_GETPAGESIZE 1" >>confdefs.h fi -done +ac_fn_c_check_func "$LINENO" "kqueue" "ac_cv_func_kqueue" +if test "x$ac_cv_func_kqueue" = xyes +then : + printf "%s\n" "#define HAVE_KQUEUE 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "statfs" "ac_cv_func_statfs" +if test "x$ac_cv_func_statfs" = xyes +then : + printf "%s\n" "#define HAVE_STATFS 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "statvfs" "ac_cv_func_statvfs" +if test "x$ac_cv_func_statvfs" = xyes +then : + printf "%s\n" "#define HAVE_STATVFS 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "clone" "ac_cv_func_clone" +if test "x$ac_cv_func_clone" = xyes +then : + printf "%s\n" "#define HAVE_CLONE 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "kse_create" "ac_cv_func_kse_create" +if test "x$ac_cv_func_kse_create" = xyes +then : + printf "%s\n" "#define HAVE_KSE_CREATE 1" >>confdefs.h - for ac_header in $ac_header_list -do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` -ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default -" -if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : - cat >>confdefs.h <<_ACEOF -#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 -_ACEOF +fi +ac_fn_c_check_func "$LINENO" "rfork_thread" "ac_cv_func_rfork_thread" +if test "x$ac_cv_func_rfork_thread" = xyes +then : + printf "%s\n" "#define HAVE_RFORK_THREAD 1" >>confdefs.h fi +ac_fn_c_check_func "$LINENO" "thr_create" "ac_cv_func_thr_create" +if test "x$ac_cv_func_thr_create" = xyes +then : + printf "%s\n" "#define HAVE_THR_CREATE 1" >>confdefs.h -done +fi +ac_fn_c_check_func "$LINENO" "sa_register" "ac_cv_func_sa_register" +if test "x$ac_cv_func_sa_register" = xyes +then : + printf "%s\n" "#define HAVE_SA_REGISTER 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "getcontext" "ac_cv_func_getcontext" +if test "x$ac_cv_func_getcontext" = xyes +then : + printf "%s\n" "#define HAVE_GETCONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "makecontext" "ac_cv_func_makecontext" +if test "x$ac_cv_func_makecontext" = xyes +then : + printf "%s\n" "#define HAVE_MAKECONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "setcontext" "ac_cv_func_setcontext" +if test "x$ac_cv_func_setcontext" = xyes +then : + printf "%s\n" "#define HAVE_SETCONTEXT 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "sigaltstack" "ac_cv_func_sigaltstack" +if test "x$ac_cv_func_sigaltstack" = xyes +then : + printf "%s\n" "#define HAVE_SIGALTSTACK 1" >>confdefs.h +fi +ac_fn_c_check_func "$LINENO" "swapcontext" "ac_cv_func_swapcontext" +if test "x$ac_cv_func_swapcontext" = xyes +then : + printf "%s\n" "#define HAVE_SWAPCONTEXT 1" >>confdefs.h +fi -for ac_func in getpagesize -do : - ac_fn_c_check_func "$LINENO" "getpagesize" "ac_cv_func_getpagesize" -if test "x$ac_cv_func_getpagesize" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_GETPAGESIZE 1 -_ACEOF -fi +ac_func= +for ac_item in $ac_func_c_list +do + if test $ac_func; then + ac_fn_c_check_func "$LINENO" $ac_func ac_cv_func_$ac_func + if eval test \"x\$ac_cv_func_$ac_func\" = xyes; then + echo "#define $ac_item 1" >> confdefs.h + fi + ac_func= + else + ac_func=$ac_item + fi done -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 -$as_echo_n "checking for working mmap... " >&6; } -if ${ac_cv_func_mmap_fixed_mapped+:} false; then : - $as_echo_n "(cached) " >&6 -else - if test "$cross_compiling" = yes; then : - ac_cv_func_mmap_fixed_mapped=no -else + +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working mmap" >&5 +printf %s "checking for working mmap... " >&6; } +if test ${ac_cv_func_mmap_fixed_mapped+y} +then : + printf %s "(cached) " >&6 +else $as_nop + if test "$cross_compiling" = yes +then : + case "$host_os" in # (( + # Guess yes on platforms where we know the result. + linux*) ac_cv_func_mmap_fixed_mapped=yes ;; + # If we don't know, assume the worst. + *) ac_cv_func_mmap_fixed_mapped=no ;; + esac +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default @@ -7800,10 +8596,6 @@ $ac_includes_default #include #include -#if !defined STDC_HEADERS && !defined HAVE_STDLIB_H -char *malloc (); -#endif - /* This mess was copied from the GNU getpagesize.h. */ #ifndef HAVE_GETPAGESIZE # ifdef _SC_PAGESIZE @@ -7837,7 +8629,7 @@ char *malloc (); #endif /* no HAVE_GETPAGESIZE */ int -main () +main (void) { char *data, *data2, *data3; const char *cdata2; @@ -7910,9 +8702,10 @@ main () return 0; } _ACEOF -if ac_fn_c_try_run "$LINENO"; then : +if ac_fn_c_try_run "$LINENO" +then : ac_cv_func_mmap_fixed_mapped=yes -else +else $as_nop ac_cv_func_mmap_fixed_mapped=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ @@ -7920,11 +8713,11 @@ rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 -$as_echo "$ac_cv_func_mmap_fixed_mapped" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mmap_fixed_mapped" >&5 +printf "%s\n" "$ac_cv_func_mmap_fixed_mapped" >&6; } if test $ac_cv_func_mmap_fixed_mapped = yes; then -$as_echo "#define HAVE_MMAP 1" >>confdefs.h +printf "%s\n" "#define HAVE_MMAP 1" >>confdefs.h fi rm -f conftest.mmap conftest.txt @@ -7932,29 +8725,30 @@ rm -f conftest.mmap conftest.txt # # Disable common symbols -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-common" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fno-common... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-common" >&5 +printf %s "checking whether ${CC_BASE} accepts -fno-common... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fno-common" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_common="yes" -else +else $as_nop use_no_common="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_common" >&5 -$as_echo "$use_no_common" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_common" >&5 +printf "%s\n" "$use_no_common" >&6; } if test "x-$use_no_common" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -fno-common" fi @@ -7975,29 +8769,30 @@ CFLAGS="$save_cflags" # work on all platforms. # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-stack-protector" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fno-stack-protector... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fno-stack-protector" >&5 +printf %s "checking whether ${CC_BASE} accepts -fno-stack-protector... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fno-stack-protector" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_stack_protector="yes" -else +else $as_nop use_no_stack_protector="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 -$as_echo "$use_no_stack_protector" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +printf "%s\n" "$use_no_stack_protector" >&6; } if test "x-$use_no_stack_protector" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -fno-stack-protector" fi @@ -8008,29 +8803,30 @@ CFLAGS="$save_cflags" # Disable pointer-signedness warnings if the compiler recognises the option # (this only works for the host compiler at the moment) -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -Wno-pointer-sign" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -Wno-pointer-sign... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -Wno-pointer-sign" >&5 +printf %s "checking whether ${CC_BASE} accepts -Wno-pointer-sign... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -Wno-pointer-sign" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_sign_warning="yes" -else +else $as_nop use_no_sign_warning="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_sign_warning" >&5 -$as_echo "$use_no_sign_warning" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_sign_warning" >&5 +printf "%s\n" "$use_no_sign_warning" >&6; } if test "x-$use_no_sign_warning" = "x-yes" ; then aros_host_cflags="$aros_host_cflags -Wno-pointer-sign" fi @@ -8040,29 +8836,30 @@ CFLAGS="$save_cflags" # Check if host compiler supports -fgnu89-inline, can be needed for crosstools. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fgnu89-inline" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -fgnu89-inline... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -fgnu89-inline" >&5 +printf %s "checking whether ${CC_BASE} accepts -fgnu89-inline... " >&6; } save_cflags="$CFLAGS" CFLAGS="$CFLAGS -fgnu89-inline" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_gnu89_inline="yes" -else +else $as_nop use_gnu89_inline="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_gnu89_inline" >&5 -$as_echo "$use_gnu89_inline" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_gnu89_inline" >&5 +printf "%s\n" "$use_gnu89_inline" >&6; } if test "x-$use_gnu89_inline" = "x-yes" ; then gnu89_inline="-fgnu89-inline" fi @@ -8072,28 +8869,29 @@ CFLAGS="$save_cflags" # For GCC < 4.0 -I- is used for giving the search path for '#include "..."' # On GCC >= 4.0 -iquote should be used # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -iquote" >&5 -$as_echo_n "checking whether ${CC_BASE} accepts -iquote... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC_BASE} accepts -iquote" >&5 +printf %s "checking whether ${CC_BASE} accepts -iquote... " >&6; } CFLAGS="$CFLAGS -iquote." cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : has_iquote="yes" -else +else $as_nop has_iquote="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 -$as_echo "$has_iquote" >&6; } +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +printf "%s\n" "$has_iquote" >&6; } if test "x-$has_iquote" = "x-yes" ; then host_cflags_iquote=-iquote host_cflags_iquote_end= @@ -8102,8 +8900,8 @@ else host_cflags_iquote_end=-I- fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: Performing target configuration..." >&5 -$as_echo "$as_me: Performing target configuration..." >&6;} +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: Performing target configuration..." >&5 +printf "%s\n" "$as_me: Performing target configuration..." >&6;} test_kernel_cc=no @@ -8155,49 +8953,52 @@ ignore_undefined_symbols="" # Check for X11 by default need_x11="auto" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Which toolchain family to use ..." >&5 -$as_echo_n "checking Which toolchain family to use ...... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which toolchain family to use ..." >&5 +printf %s "checking Which toolchain family to use ...... " >&6; } # Check whether --with-toolchain was given. -if test "${with_toolchain+set}" = set; then : +if test ${with_toolchain+y} +then : withval=$with_toolchain; aros_toolchain="$withval" -else +else $as_nop aros_toolchain="$default_toolchain_family" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_toolchain" >&5 -$as_echo "$aros_toolchain" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_toolchain" >&5 +printf "%s\n" "$aros_toolchain" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable link time optimizations (LTO)" >&5 -$as_echo_n "checking if we should enable link time optimizations (LTO)... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should enable link time optimizations (LTO)" >&5 +printf %s "checking if we should enable link time optimizations (LTO)... " >&6; } # Check whether --enable-lto was given. -if test "${enable_lto+set}" = set; then : +if test ${enable_lto+y} +then : enableval=$enable_lto; aros_config_lto="$enableval" -else +else $as_nop aros_config_lto="no" fi if test "$aros_config_lto" != "no"; then aros_config_lto="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_lto" >&5 -$as_echo "$aros_config_lto" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_config_lto" >&5 +printf "%s\n" "$aros_config_lto" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should enable coverage instrumentation" >&5 -$as_echo_n "checking if we should enable coverage instrumentation... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should enable coverage instrumentation" >&5 +printf %s "checking if we should enable coverage instrumentation... " >&6; } # Check whether --enable-coverage was given. -if test "${enable_coverage+set}" = set; then : +if test ${enable_coverage+y} +then : enableval=$enable_coverage; aros_config_coverage="$enableval" -else +else $as_nop aros_config_coverage="no" fi if test "$aros_config_coverage" != "no"; then aros_config_coverage="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_config_coverage" >&5 -$as_echo "$aros_config_coverage" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_config_coverage" >&5 +printf "%s\n" "$aros_config_coverage" >&6; } use_ld_wrapper=yes @@ -8252,8 +9053,8 @@ case "$aros_toolchain" in aros_cxx_ldflags="-static-libstdc++" ;; *) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown toolchain family!\"" >&5 -$as_echo "$as_me: WARNING: \"Unknown toolchain family!\"" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: \"Unknown toolchain family!\"" >&5 +printf "%s\n" "$as_me: WARNING: \"Unknown toolchain family!\"" >&2;} toolchain_c_compiler="cc" toolchain_cxx_compiler="c++" toolchain_cpp_preprocessor="cpp" @@ -8272,12 +9073,13 @@ esac #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which type of build to do" >&5 -$as_echo_n "checking which type of build to do... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which type of build to do" >&5 +printf %s "checking which type of build to do... " >&6; } # Check whether --enable-build_type was given. -if test "${enable_build_type+set}" = set; then : +if test ${enable_build_type+y} +then : enableval=$enable_build_type; build_type=$enableval -else +else $as_nop build_type="personal" fi @@ -8297,18 +9099,19 @@ fi aros_config_cppflags="$aros_config_cppflags -DAROS_BUILD_TYPE=AROS_BUILD_TYPE_$build_type_string" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $build_type" >&5 -$as_echo "$build_type" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $build_type" >&5 +printf "%s\n" "$build_type" >&6; } #----------------------------------------------------------------------------- all_debug_types="messages stack modules mungwall symbols" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug types to enable" >&5 -$as_echo_n "checking which debug types to enable... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which debug types to enable" >&5 +printf %s "checking which debug types to enable... " >&6; } # Check whether --enable-debug was given. -if test "${enable_debug+set}" = set; then : +if test ${enable_debug+y} +then : enableval=$enable_debug; debug="$enableval" -else +else $as_nop debug="" fi @@ -8347,8 +9150,8 @@ if test "$debug" != "none"; then done aros_debug="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $debug" >&5 -$as_echo "$debug" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $debug" >&5 +printf "%s\n" "$debug" >&6; } if test "$aros_messages_debug" = "1"; then aros_messages_debug="-DADEBUG=1 -DMDEBUG=1" @@ -8374,12 +9177,13 @@ aros_debug_ldflags="$aros_symbols_debug" # Always apply the transforms in this particular order. Basically you should # always run 'ccache distcc compiler' in that order for the best performance. # -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable distcc" >&5 -$as_echo_n "checking whether to enable distcc... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable distcc" >&5 +printf %s "checking whether to enable distcc... " >&6; } # Check whether --enable-distcc was given. -if test "${enable_distcc+set}" = set; then : +if test ${enable_distcc+y} +then : enableval=$enable_distcc; distcc="$enableval" -else +else $as_nop distcc="no" fi @@ -8387,11 +9191,12 @@ if test "$distcc" != "" -a "$distcc" != "no"; then # AC_CHECK_PROG will print out the result in this case # Extract the first word of "distcc", so it can be a program name with args. set dummy distcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_DISTCC+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_DISTCC+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $DISTCC in [\\/]* | ?:[\\/]*) ac_cv_path_DISTCC="$DISTCC" # Let the user override the test with a path. @@ -8401,11 +9206,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_DISTCC="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_DISTCC="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8418,25 +9227,26 @@ esac fi DISTCC=$ac_cv_path_DISTCC if test -n "$DISTCC"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DISTCC" >&5 -$as_echo "$DISTCC" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DISTCC" >&5 +printf "%s\n" "$DISTCC" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable ccache" >&5 -$as_echo_n "checking whether to enable ccache... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable ccache" >&5 +printf %s "checking whether to enable ccache... " >&6; } # Check whether --enable-ccache was given. -if test "${enable_ccache+set}" = set; then : +if test ${enable_ccache+y} +then : enableval=$enable_ccache; ccache="$enableval" -else +else $as_nop ccache="no" fi @@ -8444,11 +9254,12 @@ if test "$ccache" != "" -a "$ccache" != "no"; then # AC_CHECK_PROG will print out the result in this case # Extract the first word of "ccache", so it can be a program name with args. set dummy ccache; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_prog_CCACHE+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_CCACHE+y} +then : + printf %s "(cached) " >&6 +else $as_nop if test -n "$CCACHE"; then ac_cv_prog_CCACHE="$CCACHE" # Let the user override the test. else @@ -8456,11 +9267,15 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac for ac_exec_ext in '' $ac_executable_extensions; do - if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then ac_cv_prog_CCACHE="ccache" - $as_echo "$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 @@ -8471,27 +9286,28 @@ fi fi CCACHE=$ac_cv_prog_CCACHE if test -n "$CCACHE"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 -$as_echo "$CCACHE" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5 +printf "%s\n" "$CCACHE" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific host gcc version to use" >&5 -$as_echo_n "checking what specific host gcc version to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific host gcc version to use" >&5 +printf %s "checking what specific host gcc version to use... " >&6; } # Check whether --with-kernel-gcc-version was given. -if test "${with_kernel_gcc_version+set}" = set; then : +if test ${with_kernel_gcc_version+y} +then : withval=$with_kernel_gcc_version; kernel_tool_version="$withval" -else +else $as_nop kernel_tool_version="" fi @@ -8500,17 +9316,18 @@ if test "$kernel_tool_version" != "" ; then else msg_result="default" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what optimization flags to use" >&5 -$as_echo_n "checking what optimization flags to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what optimization flags to use" >&5 +printf %s "checking what optimization flags to use... " >&6; } # Check whether --with-optimization was given. -if test "${with_optimization+set}" = set; then : +if test ${with_optimization+y} +then : withval=$with_optimization; optimization_level="$withval" -else +else $as_nop optimization_level="unknown" fi @@ -8524,18 +9341,19 @@ if test "$optimization_level" = "unknown"; then else optimization="$optimization_level" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization" >&5 -$as_echo "$optimization" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $optimization" >&5 +printf "%s\n" "$optimization" >&6; } paranoia_default=yes #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which paranoia flags to use" >&5 -$as_echo_n "checking which paranoia flags to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which paranoia flags to use" >&5 +printf %s "checking which paranoia flags to use... " >&6; } # Check whether --with-paranoia was given. -if test "${with_paranoia+set}" = set; then : +if test ${with_paranoia+y} +then : withval=$with_paranoia; paranoia_flags="$withval" -else +else $as_nop paranoia_flags="$paranoia_default" fi @@ -8548,17 +9366,18 @@ else fi msg_result="$paranoia_flags" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } aros_warn_flags="$aros_warn_flags $paranoia_flags" #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what target variant to enable" >&5 -$as_echo_n "checking what target variant to enable... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what target variant to enable" >&5 +printf %s "checking what target variant to enable... " >&6; } # Check whether --enable-target_variant was given. -if test "${enable_target_variant+set}" = set; then : +if test ${enable_target_variant+y} +then : enableval=$enable_target_variant; target_variant=$enableval -else +else $as_nop target_variant="" fi @@ -8570,16 +9389,17 @@ else aros_target_variant="$target_variant" aros_target_suffix="-$target_variant" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5 -$as_echo "$enableval" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enableval" >&5 +printf "%s\n" "$enableval" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro name to use" >&5 -$as_echo_n "checking what distro name to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro name to use" >&5 +printf %s "checking what distro name to use... " >&6; } # Check whether --enable-dist_name was given. -if test "${enable_dist_name+set}" = set; then : +if test ${enable_dist_name+y} +then : enableval=$enable_dist_name; dist_name="$enableval" -else +else $as_nop dist_name="" fi @@ -8588,16 +9408,17 @@ if test "$dist_name" = ""; then else aros_dist_name="$dist_name" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_name" >&5 -$as_echo "$aros_dist_name" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_name" >&5 +printf "%s\n" "$aros_dist_name" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro version" >&5 -$as_echo_n "checking what distro version... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro version" >&5 +printf %s "checking what distro version... " >&6; } # Check whether --enable-dist_version was given. -if test "${enable_dist_version+set}" = set; then : +if test ${enable_dist_version+y} +then : enableval=$enable_dist_version; dist_version="$enableval" -else +else $as_nop dist_version="" fi @@ -8606,16 +9427,17 @@ if test "$dist_version" = ""; then else aros_dist_version="$dist_version" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_version" >&5 -$as_echo "$aros_dist_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_version" >&5 +printf "%s\n" "$aros_dist_version" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro date" >&5 -$as_echo_n "checking what distro date... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro date" >&5 +printf %s "checking what distro date... " >&6; } # Check whether --enable-dist_date was given. -if test "${enable_dist_date+set}" = set; then : +if test ${enable_dist_date+y} +then : enableval=$enable_dist_date; dist_date=$enableval -else +else $as_nop dist_date="" fi @@ -8624,16 +9446,17 @@ if test "$dist_date" = ""; then else aros_dist_date="$dist_date" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_date" >&5 -$as_echo "$aros_dist_date" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_date" >&5 +printf "%s\n" "$aros_dist_date" >&6; } #----------------------------------------------------------------------------- -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking what distro amigadate" >&5 -$as_echo_n "checking what distro amigadate... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what distro amigadate" >&5 +printf %s "checking what distro amigadate... " >&6; } # Check whether --enable-dist_amigadate was given. -if test "${enable_dist_amigadate+set}" = set; then : +if test ${enable_dist_amigadate+y} +then : enableval=$enable_dist_amigadate; dist_amigadate=$enableval -else +else $as_nop dist_amigadate="" fi @@ -8642,8 +9465,8 @@ if test "$dist_amigadate" = ""; then else aros_dist_amigadate="$dist_amigadate" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_dist_amigadate" >&5 -$as_echo "$aros_dist_amigadate" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_dist_amigadate" >&5 +printf "%s\n" "$aros_dist_amigadate" >&6; } #----------------------------------------------------------------------------- @@ -8659,73 +9482,78 @@ ENABLE_EXECSMP= case "$aros_target_variant" in ios) - { $as_echo "$as_me:${as_lineno-$LINENO}: checking XCode path" >&5 -$as_echo_n "checking XCode path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking XCode path" >&5 +printf %s "checking XCode path... " >&6; } # Check whether --with-xcode was given. -if test "${with_xcode+set}" = set; then : +if test ${with_xcode+y} +then : withval=$with_xcode; aros_xcode_path="$withval" -else +else $as_nop aros_xcode_path="/Developer" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_xcode_path" >&5 -$as_echo "$aros_xcode_path" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_xcode_path" >&5 +printf "%s\n" "$aros_xcode_path" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what iOS SDK version to use" >&5 -$as_echo_n "checking what iOS SDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what iOS SDK version to use" >&5 +printf %s "checking what iOS SDK version to use... " >&6; } # Check whether --with-sdk-version was given. -if test "${with_sdk_version+set}" = set; then : +if test ${with_sdk_version+y} +then : withval=$with_sdk_version; aros_sdk_version="$withval" -else +else $as_nop aros_sdk_version="4.1" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 -$as_echo "$aros_sdk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +printf "%s\n" "$aros_sdk_version" >&6; } ;; "android") - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android SDK path" >&5 -$as_echo_n "checking Android SDK path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Android SDK path" >&5 +printf %s "checking Android SDK path... " >&6; } # Check whether --with-sdk was given. -if test "${with_sdk+set}" = set; then : +if test ${with_sdk+y} +then : withval=$with_sdk; aros_android_sdk="$withval" -else +else $as_nop aros_android_sdk=$default_android_sdk fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_sdk" >&5 -$as_echo "$aros_android_sdk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_sdk" >&5 +printf "%s\n" "$aros_android_sdk" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Android NDK path" >&5 -$as_echo_n "checking Android NDK path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Android NDK path" >&5 +printf %s "checking Android NDK path... " >&6; } # Check whether --with-ndk was given. -if test "${with_ndk+set}" = set; then : +if test ${with_ndk+y} +then : withval=$with_ndk; aros_android_ndk="$withval" -else +else $as_nop aros_android_ndk="none" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_ndk" >&5 -$as_echo "$aros_android_ndk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_ndk" >&5 +printf "%s\n" "$aros_android_ndk" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android SDK version to use" >&5 -$as_echo_n "checking what Android SDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what Android SDK version to use" >&5 +printf %s "checking what Android SDK version to use... " >&6; } # Check whether --with-sdk-version was given. -if test "${with_sdk_version+set}" = set; then : +if test ${with_sdk_version+y} +then : withval=$with_sdk_version; aros_sdk_version="$withval" -else +else $as_nop aros_sdk_version="12" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 -$as_echo "$aros_sdk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_sdk_version" >&5 +printf "%s\n" "$aros_sdk_version" >&6; } aros_android_level=android-$aros_sdk_version if test ! -d $aros_android_sdk/platforms/$aros_android_level; then @@ -8739,11 +9567,12 @@ $as_echo "$aros_sdk_version" >&6; } export PATH="$aros_android_sdk/tools:$PATH" # Extract the first word of "$android_tool", so it can be a program name with args. set dummy $android_tool; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_android_tool+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_android_tool+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $android_tool in [\\/]* | ?:[\\/]*) ac_cv_path_android_tool="$android_tool" # Let the user override the test with a path. @@ -8753,11 +9582,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_android_tool="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_android_tool="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8769,11 +9602,11 @@ esac fi android_tool=$ac_cv_path_android_tool if test -n "$android_tool"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $android_tool" >&5 -$as_echo "$android_tool" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $android_tool" >&5 +printf "%s\n" "$android_tool" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -8789,27 +9622,29 @@ if test "$req_avail" = "no"; then fi if test "$aros_android_ndk" != "none"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what Android NDK version to use" >&5 -$as_echo_n "checking what Android NDK version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what Android NDK version to use" >&5 +printf %s "checking what Android NDK version to use... " >&6; } # Check whether --with-ndk-version was given. -if test "${with_ndk_version+set}" = set; then : +if test ${with_ndk_version+y} +then : withval=$with_ndk_version; aros_ndk_version="$withval" -else +else $as_nop aros_ndk_version="9" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_ndk_version" >&5 -$as_echo "$aros_ndk_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_ndk_version" >&5 +printf "%s\n" "$aros_ndk_version" >&6; } fi # Extract the first word of "ant", so it can be a program name with args. set dummy ant; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_ant+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_ant+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $ant in [\\/]* | ?:[\\/]*) ac_cv_path_ant="$ant" # Let the user override the test with a path. @@ -8819,11 +9654,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_ant="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_ant="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -8835,34 +9674,35 @@ esac fi ant=$ac_cv_path_ant if test -n "$ant"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ant" >&5 -$as_echo "$ant" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ant" >&5 +printf "%s\n" "$ant" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi if test "$ant" = ""; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&5 -$as_echo "$as_me: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&5 +printf "%s\n" "$as_me: WARNING: Apache Ant is missing, Java bootstrap can't be built automatically" >&2;} fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Build debug or release apk" >&5 -$as_echo_n "checking Build debug or release apk... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Build debug or release apk" >&5 +printf %s "checking Build debug or release apk... " >&6; } # Check whether --with-apk-version was given. -if test "${with_apk_version+set}" = set; then : +if test ${with_apk_version+y} +then : withval=$with_apk_version; aros_android_antapk=$withval -else +else $as_nop aros_android_antapk=release fi if test $aros_android_antapk != release -a $aros_android_antapk != debug; then as_fn_error $? "apk-version has to be release or debug" "$LINENO" 5 fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_android_antapk" >&5 -$as_echo "$aros_android_antapk" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_android_antapk" >&5 +printf "%s\n" "$aros_android_antapk" >&6; } target_extra_cfg+="$export_newline""# Android$export_newline""AROS_ANDROID_ANTAPK := $aros_android_antapk$export_newline" host_extra_cfg+="$export_newline""# Android-specific$export_newline""ANDROID := $android_tool$export_newline""ANT := $ant$export_newline" @@ -9584,7 +10424,8 @@ case "$target_os" in case "$target_cpu" in *m68k*) # Check whether --enable-amigaos_compliance was given. -if test "${enable_amigaos_compliance+set}" = set; then : +if test ${enable_amigaos_compliance+y} +then : enableval=$enable_amigaos_compliance; aros_amigaos_compliance="$enableval" fi @@ -9750,34 +10591,37 @@ crosstools_guess="yes" aros_target_toolchain="no" aros_kernel_sysroot="" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Kernel toolchain prefix" >&5 -$as_echo_n "checking Kernel toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Kernel toolchain prefix" >&5 +printf %s "checking Kernel toolchain prefix... " >&6; } # Check whether --with-kernel-toolchain-prefix was given. -if test "${with_kernel_toolchain_prefix+set}" = set; then : +if test ${with_kernel_toolchain_prefix+y} +then : withval=$with_kernel_toolchain_prefix; kernel_tool_prefix="$withval" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 -$as_echo "$kernel_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +printf "%s\n" "$kernel_tool_prefix" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking ELF toolchain prefix" >&5 -$as_echo_n "checking ELF toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking ELF toolchain prefix" >&5 +printf %s "checking ELF toolchain prefix... " >&6; } # Check whether --with-elf-toolchain-prefix was given. -if test "${with_elf_toolchain_prefix+set}" = set; then : +if test ${with_elf_toolchain_prefix+y} +then : withval=$with_elf_toolchain_prefix; elf_tool_prefix="$withval" crosstools_guess="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $elf_tool_prefix" >&5 -$as_echo "$elf_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $elf_tool_prefix" >&5 +printf "%s\n" "$elf_tool_prefix" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking AROS toolchain prefix" >&5 -$as_echo_n "checking AROS toolchain prefix... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking AROS toolchain prefix" >&5 +printf %s "checking AROS toolchain prefix... " >&6; } # Check whether --with-aros-toolchain was given. -if test "${with_aros_toolchain+set}" = set; then : +if test ${with_aros_toolchain+y} +then : withval=$with_aros_toolchain; aros_tool_prefix="$withval" crosstools_guess="no" fi @@ -9785,22 +10629,23 @@ fi if test "$aros_tool_prefix" = "yes" ; then aros_tool_prefix=$aros_target_cpu-aros- fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 -$as_echo "$aros_tool_prefix" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +printf "%s\n" "$aros_tool_prefix" >&6; } #----------------------------------------------------------------------------- # Checking if we should build crosstools.. -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build crosstools" >&5 -$as_echo_n "checking whether to build crosstools... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build crosstools" >&5 +printf %s "checking whether to build crosstools... " >&6; } # Check whether --enable-crosstools was given. -if test "${enable_crosstools+set}" = set; then : +if test ${enable_crosstools+y} +then : enableval=$enable_crosstools; crosstools="$enableval" -else +else $as_nop crosstools="$crosstools_guess" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $crosstools" >&5 -$as_echo "$crosstools" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $crosstools" >&5 +printf "%s\n" "$crosstools" >&6; } if test "${crosstools}" = "yes"; then if test "${crosstools_guess}" = "no"; then @@ -9812,11 +10657,12 @@ if test "${crosstools}" = "yes" || test "${crosstools_guess}" = "no"; then aros_target_toolchain="yes" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to install the crosstools binaries" >&5 -$as_echo_n "checking where to install the crosstools binaries... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to install the crosstools binaries" >&5 +printf %s "checking where to install the crosstools binaries... " >&6; } # Check whether --with-aros-toolchain-install was given. -if test "${with_aros_toolchain_install+set}" = set; then : +if test ${with_aros_toolchain_install+y} +then : withval=$with_aros_toolchain_install; aros_toolchain_install=$withval fi @@ -9831,19 +10677,20 @@ else fi fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_CROSSTOOLSDIR" >&5 -$as_echo "$AROS_CROSSTOOLSDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_CROSSTOOLSDIR" >&5 +printf "%s\n" "$AROS_CROSSTOOLSDIR" >&6; } #----------------------------------------------------------------------------- if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target binutils version to use" >&5 -$as_echo_n "checking what specific target binutils version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target binutils version to use" >&5 +printf %s "checking what specific target binutils version to use... " >&6; } fi # Check whether --with-binutils-version was given. -if test "${with_binutils_version+set}" = set; then : +if test ${with_binutils_version+y} +then : withval=$with_binutils_version; use_binutils_version="$withval" -else +else $as_nop use_binutils_version="" fi @@ -9853,8 +10700,8 @@ else target_binutils_version="$use_binutils_version" fi if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_binutils_version" >&5 -$as_echo "$target_binutils_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_binutils_version" >&5 +printf "%s\n" "$target_binutils_version" >&6; } fi @@ -9863,14 +10710,15 @@ fi #----------------------------------------------------------------------------- if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target gcc version to use" >&5 -$as_echo_n "checking what specific target gcc version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target gcc version to use" >&5 +printf %s "checking what specific target gcc version to use... " >&6; } fi # Check whether --with-gcc-version was given. -if test "${with_gcc_version+set}" = set; then : +if test ${with_gcc_version+y} +then : withval=$with_gcc_version; use_gcc_version="$withval" -else +else $as_nop use_gcc_version="" fi @@ -9879,22 +10727,24 @@ if test "$use_gcc_version" = ""; then if test "x$aros_toolchain_install" != "x"; then target_gcc_version="" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5 -$as_echo_n "checking gcc version... " >&6; } -if ${ax_cv_gcc_version+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking gcc version" >&5 +printf %s "checking gcc version... " >&6; } +if test ${ax_cv_gcc_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop ax_cv_gcc_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" - if test "x$ax_cv_gcc_version" = "x"; then : + if test "x$ax_cv_gcc_version" = "x" +then : ax_cv_gcc_version="" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_gcc_version" >&5 -$as_echo "$ax_cv_gcc_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_gcc_version" >&5 +printf "%s\n" "$ax_cv_gcc_version" >&6; } target_gcc_version=$ax_cv_gcc_version @@ -9907,20 +10757,20 @@ else target_gcc_version="$use_gcc_version" fi if test "$aros_toolchain" = "gnu" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_gcc_version" >&5 -$as_echo "$target_gcc_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_gcc_version" >&5 +printf "%s\n" "$target_gcc_version" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking version string style" >&5 -$as_echo_n "checking version string style... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking version string style" >&5 +printf %s "checking version string style... " >&6; } if test "${target_gcc_version#*$'-'}" != "$target_gcc_version" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: snapshot" >&5 -$as_echo "snapshot" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: snapshot" >&5 +printf "%s\n" "snapshot" >&6; } GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'-' -f1) GCC_VERSION_MINOR=-1 GCC_VERSION_PATCH=-1 else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: release" >&5 -$as_echo "release" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: release" >&5 +printf "%s\n" "release" >&6; } GCC_VERSION_MAJOR=$(echo $target_gcc_version | cut -d'.' -f1) GCC_VERSION_MINOR=$(echo $target_gcc_version | cut -d'.' -f2) GCC_VERSION_PATCH=$(echo $target_gcc_version | cut -d'.' -f3) @@ -9955,14 +10805,15 @@ fi if test "$aros_toolchain" = "llvm" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking what specific target llvm version to use" >&5 -$as_echo_n "checking what specific target llvm version to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what specific target llvm version to use" >&5 +printf %s "checking what specific target llvm version to use... " >&6; } fi # Check whether --with-llvm-version was given. -if test "${with_llvm_version+set}" = set; then : +if test ${with_llvm_version+y} +then : withval=$with_llvm_version; use_llvm_version="$withval" -else +else $as_nop use_llvm_version="" fi @@ -9971,22 +10822,24 @@ if test "$use_llvm_version" = ""; then if test "x$aros_toolchain_install" != "x"; then target_llvm_version="" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking llvm version" >&5 -$as_echo_n "checking llvm version... " >&6; } -if ${ax_cv_llvm_version+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking llvm version" >&5 +printf %s "checking llvm version... " >&6; } +if test ${ax_cv_llvm_version+y} +then : + printf %s "(cached) " >&6 +else $as_nop ax_cv_llvm_version="`$AROS_CROSSTOOLSDIR/${aros_tool_prefix}${toolchain_cpp_preprocessor}$(toolchain_cpp_opts) -dumpversion`" - if test "x$ax_cv_llvm_version" = "x"; then : + if test "x$ax_cv_llvm_version" = "x" +then : ax_cv_llvm_version="" fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_llvm_version" >&5 -$as_echo "$ax_cv_llvm_version" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_llvm_version" >&5 +printf "%s\n" "$ax_cv_llvm_version" >&6; } target_llvm_version=$ax_cv_llvm_version @@ -9999,39 +10852,41 @@ else target_llvm_version="$use_llvm_version" fi if test "$aros_toolchain" = "llvm" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_llvm_version" >&5 -$as_echo "$target_llvm_version" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_llvm_version" >&5 +printf "%s\n" "$target_llvm_version" >&6; } aros_config_cflags="$aros_config_cflags $""(CFLAGS_NO_COMMON)" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Objective-C suppport" >&5 -$as_echo_n "checking whether to enable Objective-C suppport... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable Objective-C suppport" >&5 +printf %s "checking whether to enable Objective-C suppport... " >&6; } # Check whether --enable-objc was given. -if test "${enable_objc+set}" = set; then : +if test ${enable_objc+y} +then : enableval=$enable_objc; objc="$enableval" -else +else $as_nop objc="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $objc" >&5 -$as_echo "$objc" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $objc" >&5 +printf "%s\n" "$objc" >&6; } if test "x$objc" = "xyes"; then objc_target="$objc" else objc_target="no-objc" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Java suppport" >&5 -$as_echo_n "checking whether to enable Java suppport... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable Java suppport" >&5 +printf %s "checking whether to enable Java suppport... " >&6; } # Check whether --enable-java was given. -if test "${enable_java+set}" = set; then : +if test ${enable_java+y} +then : enableval=$enable_java; java="$enableval" -else +else $as_nop java="no" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $java" >&5 -$as_echo "$java" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $java" >&5 +printf "%s\n" "$java" >&6; } if test "x$java" != "xno"; then java_target="$java" else @@ -10053,18 +10908,19 @@ case "$aros_target_cpu" in aros_isa_extra="$aros_isa_extra$m68k_020_ldflags$export_newline$m68k_030_ldflags$export_newline$m68k_040_ldflags$export_newline$m68k_060_ldflags$export_newline" aros_isa_extra="$aros_isa_extra$m68k_020_ext$export_newline$m68k_030_ext$export_newline$m68k_040_ext$export_newline$m68k_060_ext$export_newline" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 -$as_echo_n "checking Which minimum CPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +printf %s "checking Which minimum CPU to use... " >&6; } # Check whether --with-cpu was given. -if test "${with_cpu+set}" = set; then : +if test ${with_cpu+y} +then : withval=$with_cpu; aros_gcc_cpu="$withval" -else +else $as_nop aros_gcc_cpu=$gcc_default_cpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 -$as_echo "$aros_gcc_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +printf "%s\n" "$aros_gcc_cpu" >&6; } if test "$gcc_default_cpu" != "$aros_gcc_cpu"; then aros_target_cpu_extra=$aros_gcc_cpu fi @@ -10091,54 +10947,57 @@ $as_echo "$aros_gcc_cpu" >&6; } fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 -$as_echo_n "checking Which minimum CPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum CPU to use" >&5 +printf %s "checking Which minimum CPU to use... " >&6; } # Check whether --with-cpu was given. -if test "${with_cpu+set}" = set; then : +if test ${with_cpu+y} +then : withval=$with_cpu; aros_gcc_cpu="$withval" -else +else $as_nop aros_gcc_cpu=$gcc_default_cpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 -$as_echo "$aros_gcc_cpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_cpu" >&5 +printf "%s\n" "$aros_gcc_cpu" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which minimum FPU to use" >&5 -$as_echo_n "checking Which minimum FPU to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which minimum FPU to use" >&5 +printf %s "checking Which minimum FPU to use... " >&6; } # Check whether --with-fpu was given. -if test "${with_fpu+set}" = set; then : +if test ${with_fpu+y} +then : withval=$with_fpu; aros_gcc_fpu="$withval" -else +else $as_nop aros_gcc_fpu=$gcc_default_fpu fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_fpu" >&5 -$as_echo "$aros_gcc_fpu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_fpu" >&5 +printf "%s\n" "$aros_gcc_fpu" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which floating point ABI to use" >&5 -$as_echo_n "checking Which floating point ABI to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which floating point ABI to use" >&5 +printf %s "checking Which floating point ABI to use... " >&6; } # Check whether --with-float was given. -if test "${with_float+set}" = set; then : +if test ${with_float+y} +then : withval=$with_float; aros_gcc_float_abi="$withval" -else +else $as_nop aros_gcc_float_abi=$gcc_default_float_abi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_float_abi" >&5 -$as_echo "$aros_gcc_float_abi" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_gcc_float_abi" >&5 +printf "%s\n" "$aros_gcc_float_abi" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking Which ARM mode to use" >&5 -$as_echo_n "checking Which ARM mode to use... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Which ARM mode to use" >&5 +printf %s "checking Which ARM mode to use... " >&6; } if test "$aros_target_cpu_mode" = ""; then aros_target_cpu_mode="arm32" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Defaulting to $aros_target_cpu_mode" >&5 -$as_echo "Defaulting to $aros_target_cpu_mode" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Defaulting to $aros_target_cpu_mode" >&5 +printf "%s\n" "Defaulting to $aros_target_cpu_mode" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cpu_mode" >&5 -$as_echo "$aros_target_cpu_mode" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_cpu_mode" >&5 +printf "%s\n" "$aros_target_cpu_mode" >&6; } fi case "$aros_target_cpu_mode" in @@ -10190,13 +11049,14 @@ if test "$gcc_target_cpu" != ""; then gcc_target_cpu="-D__${gcc_target_cpu}__" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking where to download sourcecode for external ports" >&5 -$as_echo_n "checking where to download sourcecode for external ports... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to download sourcecode for external ports" >&5 +printf %s "checking where to download sourcecode for external ports... " >&6; } # Check whether --with-portssources was given. -if test "${with_portssources+set}" = set; then : +if test ${with_portssources+y} +then : withval=$with_portssources; with_portssrcdir=$withval -else +else $as_nop with_portssrcdir="default" fi @@ -10205,16 +11065,17 @@ if test "$with_portssrcdir" = "default"; then else AROS_PORTSSRCDIR="$with_portssrcdir" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AROS_PORTSSRCDIR" >&5 -$as_echo "$AROS_PORTSSRCDIR" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AROS_PORTSSRCDIR" >&5 +printf "%s\n" "$AROS_PORTSSRCDIR" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which bootloader to use" >&5 -$as_echo_n "checking which bootloader to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which bootloader to use" >&5 +printf %s "checking which bootloader to use... " >&6; } # Check whether --with-bootloader was given. -if test "${with_bootloader+set}" = set; then : +if test ${with_bootloader+y} +then : withval=$with_bootloader; target_bootloader=$withval -else +else $as_nop target_bootloader=$target_bootloader fi @@ -10223,16 +11084,17 @@ if test "$target_bootloader" = "none"; then else aros_target_bootloader="$target_bootloader" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_bootloader" >&5 -$as_echo "$target_bootloader" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_bootloader" >&5 +printf "%s\n" "$target_bootloader" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which icon-set to use" >&5 -$as_echo_n "checking which icon-set to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which icon-set to use" >&5 +printf %s "checking which icon-set to use... " >&6; } # Check whether --with-iconset was given. -if test "${with_iconset+set}" = set; then : +if test ${with_iconset+y} +then : withval=$with_iconset; target_iconset=$withval -else +else $as_nop target_iconset="default" fi @@ -10242,16 +11104,17 @@ if test "$target_iconset" = "default"; then else aros_target_iconset="$target_iconset" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $target_iconset" >&5 -$as_echo "$target_iconset" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $target_iconset" >&5 +printf "%s\n" "$target_iconset" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which GUI Theme to use" >&5 -$as_echo_n "checking which GUI Theme to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which GUI Theme to use" >&5 +printf %s "checking which GUI Theme to use... " >&6; } # Check whether --with-theme was given. -if test "${with_theme+set}" = set; then : +if test ${with_theme+y} +then : withval=$with_theme; target_guitheme=$withval -else +else $as_nop target_guitheme="default" fi @@ -10260,8 +11123,8 @@ if test "$target_guitheme" = "default"; then else aros_target_guitheme="$target_guitheme" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_guitheme" >&5 -$as_echo "$aros_target_guitheme" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_guitheme" >&5 +printf "%s\n" "$aros_target_guitheme" >&6; } # Find out if we are cross-compiling (i.e. if we can't use the host compiler # for target code) @@ -10351,10 +11214,10 @@ elif test "$aros_toolchain" = "llvm" ; then fi if test "$kernel_tool_prefix" != "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking which kernel tools" >&5 -$as_echo_n "checking which kernel tools... " >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 -$as_echo "$kernel_tool_prefix" >&6; }; + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which kernel tools" >&5 +printf %s "checking which kernel tools... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_tool_prefix" >&5 +printf "%s\n" "$kernel_tool_prefix" >&6; }; fi if test "$kernel_tool_prefix" = "none" ; then @@ -10382,11 +11245,12 @@ if test "$aros_kernel_cpp" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cpp", so it can be a program name with args. set dummy ${kernel_tool_prefix}cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10396,11 +11260,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10412,11 +11280,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10431,11 +11299,12 @@ if test "$GCC" = "yes"; then aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. set dummy `basename $aros_gcc_cpp`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10445,11 +11314,15 @@ else for as_dir in `dirname $aros_gcc_cpp` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10461,11 +11334,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10475,11 +11348,12 @@ if test "$aros_kernel_cpp" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10489,11 +11363,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10505,11 +11383,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10523,11 +11401,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cpp" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cpp", so it can be a program name with args. set dummy $aros_kernel_cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cpp="$aros_kernel_cpp" # Let the user override the test with a path. @@ -10537,11 +11416,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10553,11 +11436,11 @@ esac fi aros_kernel_cpp=$ac_cv_path_aros_kernel_cpp if test -n "$aros_kernel_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 -$as_echo "$aros_kernel_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cpp" >&5 +printf "%s\n" "$aros_kernel_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10590,11 +11473,12 @@ if test "$aros_kernel_cc" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cc", so it can be a program name with args. set dummy ${kernel_tool_prefix}cc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10604,11 +11488,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10620,11 +11508,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10639,11 +11527,12 @@ if test "$GCC" = "yes"; then aros_gcc_cc=`$CC -print-prog-name=$ac_tool_cc` # Extract the first word of "`basename $aros_gcc_[cc]`", so it can be a program name with args. set dummy `basename $aros_gcc_cc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10653,11 +11542,15 @@ else for as_dir in `dirname $aros_gcc_cc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10669,11 +11562,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10683,11 +11576,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10697,11 +11591,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10713,11 +11611,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10731,11 +11629,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cc" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cc", so it can be a program name with args. set dummy $aros_kernel_cc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cc in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cc="$aros_kernel_cc" # Let the user override the test with a path. @@ -10745,11 +11644,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10761,11 +11664,11 @@ esac fi aros_kernel_cc=$ac_cv_path_aros_kernel_cc if test -n "$aros_kernel_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 -$as_echo "$aros_kernel_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc" >&5 +printf "%s\n" "$aros_kernel_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10798,11 +11701,12 @@ if test "$aros_kernel_cxx" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}cxx", so it can be a program name with args. set dummy ${kernel_tool_prefix}cxx; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10812,11 +11716,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10828,11 +11736,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10847,11 +11755,12 @@ if test "$GCC" = "yes"; then aros_gcc_cxx=`$CC -print-prog-name=$ac_tool_cxx` # Extract the first word of "`basename $aros_gcc_[cxx]`", so it can be a program name with args. set dummy `basename $aros_gcc_cxx`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10861,11 +11770,15 @@ else for as_dir in `dirname $aros_gcc_cxx` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10877,11 +11790,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10891,11 +11804,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10905,11 +11819,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10921,11 +11839,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -10939,11 +11857,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_cxx" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_cxx", so it can be a program name with args. set dummy $aros_kernel_cxx; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_cxx="$aros_kernel_cxx" # Let the user override the test with a path. @@ -10953,11 +11872,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -10969,11 +11892,11 @@ esac fi aros_kernel_cxx=$ac_cv_path_aros_kernel_cxx if test -n "$aros_kernel_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 -$as_echo "$aros_kernel_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cxx" >&5 +printf "%s\n" "$aros_kernel_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11001,11 +11924,12 @@ if test "$aros_kernel_ld" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ld", so it can be a program name with args. set dummy ${kernel_tool_prefix}ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11015,11 +11939,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11031,11 +11959,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11050,11 +11978,12 @@ if test "$GCC" = "yes"; then aros_gcc_ld=`$CC -print-prog-name=$ac_tool_ld` # Extract the first word of "`basename $aros_gcc_[ld]`", so it can be a program name with args. set dummy `basename $aros_gcc_ld`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11064,11 +11993,15 @@ else for as_dir in `dirname $aros_gcc_ld` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11080,11 +12013,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11094,11 +12027,12 @@ if test "$aros_kernel_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11108,11 +12042,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11124,11 +12062,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11142,11 +12080,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ld" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ld", so it can be a program name with args. set dummy $aros_kernel_ld; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ld in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ld="$aros_kernel_ld" # Let the user override the test with a path. @@ -11156,11 +12095,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11172,11 +12115,11 @@ esac fi aros_kernel_ld=$ac_cv_path_aros_kernel_ld if test -n "$aros_kernel_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 -$as_echo "$aros_kernel_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ld" >&5 +printf "%s\n" "$aros_kernel_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11204,11 +12147,12 @@ if test "$aros_kernel_as" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}as", so it can be a program name with args. set dummy ${kernel_tool_prefix}as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11218,11 +12162,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11234,11 +12182,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11253,11 +12201,12 @@ if test "$GCC" = "yes"; then aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. set dummy `basename $aros_gcc_as`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11267,11 +12216,15 @@ else for as_dir in `dirname $aros_gcc_as` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11283,11 +12236,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11297,11 +12250,12 @@ if test "$aros_kernel_as" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11311,11 +12265,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11327,11 +12285,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11345,11 +12303,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_as" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_as", so it can be a program name with args. set dummy $aros_kernel_as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_as in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_as="$aros_kernel_as" # Let the user override the test with a path. @@ -11359,11 +12318,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11375,11 +12338,11 @@ esac fi aros_kernel_as=$ac_cv_path_aros_kernel_as if test -n "$aros_kernel_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 -$as_echo "$aros_kernel_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_as" >&5 +printf "%s\n" "$aros_kernel_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11412,11 +12375,12 @@ if test "$aros_kernel_ar" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ar", so it can be a program name with args. set dummy ${kernel_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11426,11 +12390,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11442,11 +12410,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11461,11 +12429,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11475,11 +12444,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11491,11 +12464,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11505,11 +12478,12 @@ if test "$aros_kernel_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11519,11 +12493,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11535,11 +12513,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11553,11 +12531,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ar" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ar", so it can be a program name with args. set dummy $aros_kernel_ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ar in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ar="$aros_kernel_ar" # Let the user override the test with a path. @@ -11567,11 +12546,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11583,11 +12566,11 @@ esac fi aros_kernel_ar=$ac_cv_path_aros_kernel_ar if test -n "$aros_kernel_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 -$as_echo "$aros_kernel_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ar" >&5 +printf "%s\n" "$aros_kernel_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11619,11 +12602,12 @@ if test "$aros_kernel_ranlib" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}ranlib", so it can be a program name with args. set dummy ${kernel_tool_prefix}ranlib; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11633,11 +12617,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11649,11 +12637,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11668,11 +12656,12 @@ if test "$GCC" = "yes"; then aros_gcc_ranlib=`$CC -print-prog-name=$ac_tool_ranlib` # Extract the first word of "`basename $aros_gcc_[ranlib]`", so it can be a program name with args. set dummy `basename $aros_gcc_ranlib`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11682,11 +12671,15 @@ else for as_dir in `dirname $aros_gcc_ranlib` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11698,11 +12691,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11712,11 +12705,12 @@ if test "$aros_kernel_ranlib" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11726,11 +12720,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11742,11 +12740,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11760,11 +12758,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_ranlib" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_ranlib", so it can be a program name with args. set dummy $aros_kernel_ranlib; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_ranlib="$aros_kernel_ranlib" # Let the user override the test with a path. @@ -11774,11 +12773,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11790,11 +12793,11 @@ esac fi aros_kernel_ranlib=$ac_cv_path_aros_kernel_ranlib if test -n "$aros_kernel_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 -$as_echo "$aros_kernel_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_ranlib" >&5 +printf "%s\n" "$aros_kernel_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11822,11 +12825,12 @@ if test "$aros_kernel_nm" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}nm", so it can be a program name with args. set dummy ${kernel_tool_prefix}nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11836,11 +12840,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11852,11 +12860,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11871,11 +12879,12 @@ if test "$GCC" = "yes"; then aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. set dummy `basename $aros_gcc_nm`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11885,11 +12894,15 @@ else for as_dir in `dirname $aros_gcc_nm` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11901,11 +12914,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11915,11 +12928,12 @@ if test "$aros_kernel_nm" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11929,11 +12943,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11945,11 +12963,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -11963,11 +12981,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_nm" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_nm", so it can be a program name with args. set dummy $aros_kernel_nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_nm in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_nm="$aros_kernel_nm" # Let the user override the test with a path. @@ -11977,11 +12996,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -11993,11 +13016,11 @@ esac fi aros_kernel_nm=$ac_cv_path_aros_kernel_nm if test -n "$aros_kernel_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 -$as_echo "$aros_kernel_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_nm" >&5 +printf "%s\n" "$aros_kernel_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12019,11 +13042,12 @@ if test "$aros_kernel_strip" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}strip", so it can be a program name with args. set dummy ${kernel_tool_prefix}strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12033,11 +13057,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12049,11 +13077,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12068,11 +13096,12 @@ if test "$GCC" = "yes"; then aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. set dummy `basename $aros_gcc_strip`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12082,11 +13111,15 @@ else for as_dir in `dirname $aros_gcc_strip` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12098,11 +13131,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12112,11 +13145,12 @@ if test "$aros_kernel_strip" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12126,11 +13160,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12142,11 +13180,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12160,11 +13198,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_strip" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_strip", so it can be a program name with args. set dummy $aros_kernel_strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_strip in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_strip="$aros_kernel_strip" # Let the user override the test with a path. @@ -12174,11 +13213,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12190,11 +13233,11 @@ esac fi aros_kernel_strip=$ac_cv_path_aros_kernel_strip if test -n "$aros_kernel_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 -$as_echo "$aros_kernel_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_strip" >&5 +printf "%s\n" "$aros_kernel_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12226,11 +13269,12 @@ if test "$aros_kernel_objcopy" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}objcopy", so it can be a program name with args. set dummy ${kernel_tool_prefix}objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12240,11 +13284,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12256,11 +13304,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12275,11 +13323,12 @@ if test "$GCC" = "yes"; then aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. set dummy `basename $aros_gcc_objcopy`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12289,11 +13338,15 @@ else for as_dir in `dirname $aros_gcc_objcopy` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12305,11 +13358,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12319,11 +13372,12 @@ if test "$aros_kernel_objcopy" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12333,11 +13387,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12349,11 +13407,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12367,11 +13425,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_objcopy" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_objcopy", so it can be a program name with args. set dummy $aros_kernel_objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objcopy="$aros_kernel_objcopy" # Let the user override the test with a path. @@ -12381,11 +13440,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12397,11 +13460,11 @@ esac fi aros_kernel_objcopy=$ac_cv_path_aros_kernel_objcopy if test -n "$aros_kernel_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 -$as_echo "$aros_kernel_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objcopy" >&5 +printf "%s\n" "$aros_kernel_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12419,11 +13482,12 @@ if test "$aros_kernel_objdump" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${kernel_tool_prefix}objdump", so it can be a program name with args. set dummy ${kernel_tool_prefix}objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12433,11 +13497,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12449,11 +13517,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12468,11 +13536,12 @@ if test "$GCC" = "yes"; then aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. set dummy `basename $aros_gcc_objdump`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12482,11 +13551,15 @@ else for as_dir in `dirname $aros_gcc_objdump` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12498,11 +13571,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12512,11 +13585,12 @@ if test "$aros_kernel_objdump" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12526,11 +13600,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12542,11 +13620,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12560,11 +13638,12 @@ else ac_tool_optarg=`expr "X$aros_kernel_objdump" : '[^ ]* \(.*\)'` # Extract the first word of "$aros_kernel_objdump", so it can be a program name with args. set dummy $aros_kernel_objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_objdump="$aros_kernel_objdump" # Let the user override the test with a path. @@ -12574,11 +13653,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12590,11 +13673,11 @@ esac fi aros_kernel_objdump=$ac_cv_path_aros_kernel_objdump if test -n "$aros_kernel_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 -$as_echo "$aros_kernel_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_objdump" >&5 +printf "%s\n" "$aros_kernel_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12626,16 +13709,16 @@ fi fi fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which target tools to use" >&5 -$as_echo_n "checking which target tools to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which target tools to use" >&5 +printf %s "checking which target tools to use... " >&6; } if test "$aros_target_toolchain" = "yes"; then if test "$aros_toolchain" = "llvm" ; then msg_result="llvm" else msg_result=$target_tool_prefix fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 -$as_echo "$msg_result" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $msg_result" >&5 +printf "%s\n" "$msg_result" >&6; } # We are building AROS crosstools tmp_tool_prefix="$AROS_CROSSTOOLSDIR/${target_tool_prefix}" orig_target_cc="${tmp_tool_prefix}${toolchain_c_compiler}${target_tool_version}" @@ -12659,19 +13742,20 @@ else aros_tool_prefix="${elf_tool_prefix}" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 -$as_echo "$aros_tool_prefix" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_tool_prefix" >&5 +printf "%s\n" "$aros_tool_prefix" >&6; } # We are *not* building AROS crosstools - use the AROS or ELF tools if test "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}cpp", so it can be a program name with args. set dummy ${target_tool_prefix}cpp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12681,11 +13765,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12697,11 +13785,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12716,11 +13804,12 @@ if test "$GCC" = "yes"; then aros_gcc_cpp=`$CC -print-prog-name=$ac_tool_cpp` # Extract the first word of "`basename $aros_gcc_[cpp]`", so it can be a program name with args. set dummy `basename $aros_gcc_cpp`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12730,11 +13819,15 @@ else for as_dir in `dirname $aros_gcc_cpp` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12746,11 +13839,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12760,11 +13853,12 @@ if test "$orig_target_cpp" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12774,11 +13868,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12790,11 +13888,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12808,11 +13906,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_cpp_preprocessor}${target_tool_version}${toolchain_cpp_opts}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cpp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cpp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cpp in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cpp="$orig_target_cpp" # Let the user override the test with a path. @@ -12822,11 +13921,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cpp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cpp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12838,11 +13941,11 @@ esac fi orig_target_cpp=$ac_cv_path_orig_target_cpp if test -n "$orig_target_cpp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 -$as_echo "$orig_target_cpp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cpp" >&5 +printf "%s\n" "$orig_target_cpp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12864,11 +13967,12 @@ if test "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" = ""; if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. set dummy ${target_tool_prefix}gcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12878,11 +13982,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12894,11 +14002,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12913,11 +14021,12 @@ if test "$GCC" = "yes"; then aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. set dummy `basename $aros_gcc_gcc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12927,11 +14036,15 @@ else for as_dir in `dirname $aros_gcc_gcc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12943,11 +14056,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -12957,11 +14070,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -12971,11 +14085,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -12987,11 +14105,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13005,11 +14123,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_c_compiler}${target_tool_version}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cc+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cc+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cc in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cc="$orig_target_cc" # Let the user override the test with a path. @@ -13019,11 +14138,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cc="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cc="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13035,11 +14158,11 @@ esac fi orig_target_cc=$ac_cv_path_orig_target_cc if test -n "$orig_target_cc"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 -$as_echo "$orig_target_cc" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cc" >&5 +printf "%s\n" "$orig_target_cc" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13061,11 +14184,12 @@ if test "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" = " if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}g++", so it can be a program name with args. set dummy ${target_tool_prefix}g++; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13075,11 +14199,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13091,11 +14219,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13110,11 +14238,12 @@ if test "$GCC" = "yes"; then aros_gcc_g++=`$CC -print-prog-name=$ac_tool_g++` # Extract the first word of "`basename $aros_gcc_[g++]`", so it can be a program name with args. set dummy `basename $aros_gcc_g++`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13124,11 +14253,15 @@ else for as_dir in `dirname $aros_gcc_g++` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13140,11 +14273,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13154,11 +14287,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13168,11 +14302,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13184,11 +14322,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13202,11 +14340,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_cxx_compiler}${target_tool_version}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_cxx+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_cxx+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_cxx in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_cxx="$orig_target_cxx" # Let the user override the test with a path. @@ -13216,11 +14355,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_cxx="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_cxx="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13232,11 +14375,11 @@ esac fi orig_target_cxx=$ac_cv_path_orig_target_cxx if test -n "$orig_target_cxx"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 -$as_echo "$orig_target_cxx" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_cxx" >&5 +printf "%s\n" "$orig_target_cxx" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13258,11 +14401,12 @@ if test "${aros_tool_prefix}${toolchain_ld}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}gcc", so it can be a program name with args. set dummy ${target_tool_prefix}gcc; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13272,11 +14416,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13288,11 +14436,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13307,11 +14455,12 @@ if test "$GCC" = "yes"; then aros_gcc_gcc=`$CC -print-prog-name=$ac_tool_gcc` # Extract the first word of "`basename $aros_gcc_[gcc]`", so it can be a program name with args. set dummy `basename $aros_gcc_gcc`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13321,11 +14470,15 @@ else for as_dir in `dirname $aros_gcc_gcc` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13337,11 +14490,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13351,11 +14504,12 @@ if test "$orig_target_ld" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13365,11 +14519,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13381,11 +14539,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13399,11 +14557,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ld}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ld}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ld}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ld+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ld+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ld in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ld="$orig_target_ld" # Let the user override the test with a path. @@ -13413,11 +14572,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ld="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ld="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13429,11 +14592,11 @@ esac fi orig_target_ld=$ac_cv_path_orig_target_ld if test -n "$orig_target_ld"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 -$as_echo "$orig_target_ld" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ld" >&5 +printf "%s\n" "$orig_target_ld" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13455,11 +14618,12 @@ if test "aros_tool_prefix}${toolchain_as}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}as", so it can be a program name with args. set dummy ${target_tool_prefix}as; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13469,11 +14633,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13485,11 +14653,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13504,11 +14672,12 @@ if test "$GCC" = "yes"; then aros_gcc_as=`$CC -print-prog-name=$ac_tool_as` # Extract the first word of "`basename $aros_gcc_[as]`", so it can be a program name with args. set dummy `basename $aros_gcc_as`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13518,11 +14687,15 @@ else for as_dir in `dirname $aros_gcc_as` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13534,11 +14707,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13548,11 +14721,12 @@ if test "$orig_target_as" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13562,11 +14736,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13578,11 +14756,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13596,11 +14774,12 @@ else ac_tool_optarg=`expr "Xaros_tool_prefix}${toolchain_as}" : '[^ ]* \(.*\)'` # Extract the first word of "aros_tool_prefix}${toolchain_as}", so it can be a program name with args. set dummy aros_tool_prefix}${toolchain_as}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_as+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_as+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_as in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_as="$orig_target_as" # Let the user override the test with a path. @@ -13610,11 +14789,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_as="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_as="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13626,11 +14809,11 @@ esac fi orig_target_as=$ac_cv_path_orig_target_as if test -n "$orig_target_as"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 -$as_echo "$orig_target_as" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_as" >&5 +printf "%s\n" "$orig_target_as" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13652,11 +14835,12 @@ if test "${aros_tool_prefix}${toolchain_ar}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. set dummy ${target_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13666,11 +14850,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13682,11 +14870,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13701,11 +14889,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13715,11 +14904,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13731,11 +14924,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13745,11 +14938,12 @@ if test "$orig_target_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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13759,11 +14953,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13775,11 +14973,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13793,11 +14991,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ar}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ar}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ar}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ar+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ar+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ar in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ar="$orig_target_ar" # Let the user override the test with a path. @@ -13807,11 +15006,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ar="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ar="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13823,11 +15026,11 @@ esac fi orig_target_ar=$ac_cv_path_orig_target_ar if test -n "$orig_target_ar"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 -$as_echo "$orig_target_ar" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ar" >&5 +printf "%s\n" "$orig_target_ar" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13849,11 +15052,12 @@ if test "${aros_tool_prefix}${toolchain_ranlib}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}ar", so it can be a program name with args. set dummy ${target_tool_prefix}ar; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13863,11 +15067,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13879,11 +15087,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13898,11 +15106,12 @@ if test "$GCC" = "yes"; then aros_gcc_ar=`$CC -print-prog-name=$ac_tool_ar` # Extract the first word of "`basename $aros_gcc_[ar]`", so it can be a program name with args. set dummy `basename $aros_gcc_ar`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13912,11 +15121,15 @@ else for as_dir in `dirname $aros_gcc_ar` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13928,11 +15141,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13942,11 +15155,12 @@ if test "$orig_target_ranlib" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -13956,11 +15170,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -13972,11 +15190,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -13990,11 +15208,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_ranlib}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_ranlib}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_ranlib}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_ranlib+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_ranlib+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_ranlib in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_ranlib="$orig_target_ranlib" # Let the user override the test with a path. @@ -14004,11 +15223,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_ranlib="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_ranlib="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14020,11 +15243,11 @@ esac fi orig_target_ranlib=$ac_cv_path_orig_target_ranlib if test -n "$orig_target_ranlib"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 -$as_echo "$orig_target_ranlib" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_ranlib" >&5 +printf "%s\n" "$orig_target_ranlib" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14046,11 +15269,12 @@ if test "${aros_tool_prefix}${toolchain_nm}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}nm", so it can be a program name with args. set dummy ${target_tool_prefix}nm; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14060,11 +15284,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14076,11 +15304,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14095,11 +15323,12 @@ if test "$GCC" = "yes"; then aros_gcc_nm=`$CC -print-prog-name=$ac_tool_nm` # Extract the first word of "`basename $aros_gcc_[nm]`", so it can be a program name with args. set dummy `basename $aros_gcc_nm`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14109,11 +15338,15 @@ else for as_dir in `dirname $aros_gcc_nm` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14125,11 +15358,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14139,11 +15372,12 @@ if test "$orig_target_nm" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14153,11 +15387,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14169,11 +15407,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14187,11 +15425,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_nm}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_nm}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_nm}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_nm+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_nm+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_nm in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_nm="$orig_target_nm" # Let the user override the test with a path. @@ -14201,11 +15440,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_nm="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_nm="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14217,11 +15460,11 @@ esac fi orig_target_nm=$ac_cv_path_orig_target_nm if test -n "$orig_target_nm"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 -$as_echo "$orig_target_nm" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_nm" >&5 +printf "%s\n" "$orig_target_nm" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14244,11 +15487,12 @@ if test "${aros_tool_prefix}${toolchain_strip}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}strip", so it can be a program name with args. set dummy ${target_tool_prefix}strip; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14258,11 +15502,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14274,11 +15522,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14293,11 +15541,12 @@ if test "$GCC" = "yes"; then aros_gcc_strip=`$CC -print-prog-name=$ac_tool_strip` # Extract the first word of "`basename $aros_gcc_[strip]`", so it can be a program name with args. set dummy `basename $aros_gcc_strip`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14307,11 +15556,15 @@ else for as_dir in `dirname $aros_gcc_strip` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14323,11 +15576,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14337,11 +15590,12 @@ if test "$orig_target_strip" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14351,11 +15605,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14367,11 +15625,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14385,11 +15643,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_strip}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_strip}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_strip}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_strip+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_strip+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_strip in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_strip="$orig_target_strip" # Let the user override the test with a path. @@ -14399,11 +15658,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_strip="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_strip="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14415,11 +15678,11 @@ esac fi orig_target_strip=$ac_cv_path_orig_target_strip if test -n "$orig_target_strip"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 -$as_echo "$orig_target_strip" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_strip" >&5 +printf "%s\n" "$orig_target_strip" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14444,11 +15707,12 @@ if test "${aros_tool_prefix}${toolchain_objcopy}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}objcopy", so it can be a program name with args. set dummy ${target_tool_prefix}objcopy; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14458,11 +15722,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14474,11 +15742,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14493,11 +15761,12 @@ if test "$GCC" = "yes"; then aros_gcc_objcopy=`$CC -print-prog-name=$ac_tool_objcopy` # Extract the first word of "`basename $aros_gcc_[objcopy]`", so it can be a program name with args. set dummy `basename $aros_gcc_objcopy`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14507,11 +15776,15 @@ else for as_dir in `dirname $aros_gcc_objcopy` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14523,11 +15796,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14537,11 +15810,12 @@ if test "$orig_target_objcopy" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14551,11 +15825,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14567,11 +15845,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14585,11 +15863,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objcopy}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_objcopy}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_objcopy}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objcopy+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objcopy+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objcopy in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objcopy="$orig_target_objcopy" # Let the user override the test with a path. @@ -14599,11 +15878,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objcopy="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objcopy="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14615,11 +15898,11 @@ esac fi orig_target_objcopy=$ac_cv_path_orig_target_objcopy if test -n "$orig_target_objcopy"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 -$as_echo "$orig_target_objcopy" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objcopy" >&5 +printf "%s\n" "$orig_target_objcopy" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14641,11 +15924,12 @@ if test "${aros_tool_prefix}${toolchain_objdump}" = ""; then if test "$cross_compiling" = "yes" ; then # Extract the first word of "${target_tool_prefix}objdump", so it can be a program name with args. set dummy ${target_tool_prefix}objdump; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14655,11 +15939,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14671,11 +15959,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14690,11 +15978,12 @@ if test "$GCC" = "yes"; then aros_gcc_objdump=`$CC -print-prog-name=$ac_tool_objdump` # Extract the first word of "`basename $aros_gcc_[objdump]`", so it can be a program name with args. set dummy `basename $aros_gcc_objdump`; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14704,11 +15993,15 @@ else for as_dir in `dirname $aros_gcc_objdump` do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14720,11 +16013,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14734,11 +16027,12 @@ if test "$orig_target_objdump" = ""; 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 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14748,11 +16042,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14764,11 +16062,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14782,11 +16080,12 @@ else ac_tool_optarg=`expr "X${aros_tool_prefix}${toolchain_objdump}" : '[^ ]* \(.*\)'` # Extract the first word of "${aros_tool_prefix}${toolchain_objdump}", so it can be a program name with args. set dummy ${aros_tool_prefix}${toolchain_objdump}; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_orig_target_objdump+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_orig_target_objdump+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $orig_target_objdump in [\\/]* | ?:[\\/]*) ac_cv_path_orig_target_objdump="$orig_target_objdump" # Let the user override the test with a path. @@ -14796,11 +16095,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_orig_target_objdump="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_orig_target_objdump="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14812,11 +16115,11 @@ esac fi orig_target_objdump=$ac_cv_path_orig_target_objdump if test -n "$orig_target_objdump"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 -$as_echo "$orig_target_objdump" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $orig_target_objdump" >&5 +printf "%s\n" "$orig_target_objdump" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -14879,11 +16182,12 @@ aros_target_mkdep="$aros_host_mkdep" if test "$rescomp" != ""; then # Extract the first word of "${kernel_tool_prefix}$rescomp", so it can be a program name with args. set dummy ${kernel_tool_prefix}$rescomp; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_aros_kernel_rescomp+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_aros_kernel_rescomp+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $aros_kernel_rescomp in [\\/]* | ?:[\\/]*) ac_cv_path_aros_kernel_rescomp="$aros_kernel_rescomp" # Let the user override the test with a path. @@ -14893,11 +16197,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_aros_kernel_rescomp="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_aros_kernel_rescomp="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -14909,11 +16217,11 @@ esac fi aros_kernel_rescomp=$ac_cv_path_aros_kernel_rescomp if test -n "$aros_kernel_rescomp"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_rescomp" >&5 -$as_echo "$aros_kernel_rescomp" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_rescomp" >&5 +printf "%s\n" "$aros_kernel_rescomp" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi @@ -15019,9 +16327,10 @@ aros_plain_nm="${prefix}${toolchain_nm}" aros_plain_ar="${prefix}${toolchain_ar}" # Check whether --enable-includes was given. -if test "${enable_includes+set}" = set; then : +if test ${enable_includes+y} +then : enableval=$enable_includes; aros_target_incl=$enable_includes -else +else $as_nop aros_target_incl=no fi @@ -15044,8 +16353,8 @@ fi if test "x$test_kernel_cc" != "xno"; then if test "$aros_kernel_includes" != "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the kernel compiler's include path" >&5 -$as_echo_n "checking for the kernel compiler's include path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the kernel compiler's include path" >&5 +printf %s "checking for the kernel compiler's include path... " >&6; } if test "$aros_kernel_cc_includes" = "" ; then # Try to guess where the directory is. aros_kernel_cc_includes=`dirname \`${aros_kernel_cc} ${aros_kernel_cflags} -print-libgcc-file-name\``/include @@ -15087,16 +16396,16 @@ $as_echo_n "checking for the kernel compiler's include path... " >&6; } done fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc_includes" >&5 -$as_echo "$aros_kernel_cc_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_kernel_cc_includes" >&5 +printf "%s\n" "$aros_kernel_cc_includes" >&6; } # Adding -nostdinc to kernel includes as they are always used together. aros_kernel_includes="$aros_kernel_includes $aros_target_nostdinc_cflags -isystem $aros_kernel_cc_includes" fi fi if test "$crosstools" != "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the target compiler's include path" >&5 -$as_echo_n "checking for the target compiler's include path... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the target compiler's include path" >&5 +printf %s "checking for the target compiler's include path... " >&6; } if test "$aros_target_cc_includes" = "" ; then #try to guess where the directory is aros_target_cc_includes=`dirname \`${orig_target_cc} -print-libgcc-file-name\``/include @@ -15127,8 +16436,8 @@ $as_echo_n "checking for the target compiler's include path... " >&6; } done fi fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_target_cc_includes" >&5 -$as_echo "$aros_target_cc_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_target_cc_includes" >&5 +printf "%s\n" "$aros_target_cc_includes" >&6; } else # We do not know which c compiler version we are going to build and what we need to know # here is different for different versions so this will be set later during the @@ -15144,67 +16453,69 @@ fi save_cc="$CC" save_cflags="$CFLAGS" if test "x$test_kernel_cc" != "xno"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: Testing kernel compiler..." >&5 -$as_echo "$as_me: Testing kernel compiler..." >&6;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing kernel compiler..." >&5 +printf "%s\n" "$as_me: Testing kernel compiler..." >&6;} CFLAGS="-iquote." kernel_cflags_iquote=$host_cflags_iquote kernel_cflags_iquote_end=$host_cflags_iquote_end if test "x-$cross_compiling" = "x-yes"; then CC="$aros_kernel_cc" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fno-stack-protector" >&5 -$as_echo_n "checking whether ${CC} accepts -fno-stack-protector... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -fno-stack-protector" >&5 +printf %s "checking whether ${CC} accepts -fno-stack-protector... " >&6; } if test "x-$crosstools" != "x-yes"; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : use_no_stack_protector="yes" -else +else $as_nop use_no_stack_protector="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext else # we do know it is supported for the smallest version of gcc we are going to build # we assume it's also supported by later versions use_no_stack_protector=yes fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 -$as_echo "$use_no_stack_protector" >&6; } - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -iquote" >&5 -$as_echo_n "checking whether ${CC} accepts -iquote... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_no_stack_protector" >&5 +printf "%s\n" "$use_no_stack_protector" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -iquote" >&5 +printf %s "checking whether ${CC} accepts -iquote... " >&6; } if test "x-$crosstools" != "x-yes"; then cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_compile "$LINENO"; then : +if ac_fn_c_try_compile "$LINENO" +then : has_iquote="yes" -else +else $as_nop has_iquote="no" fi -rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext else # we do know it is supported for the smallest version of gcc we are going to build # we assume it's also supported by later versions has_iquote=yes fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 -$as_echo "$has_iquote" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_iquote" >&5 +printf "%s\n" "$has_iquote" >&6; } if test "x-$has_iquote" = "x-yes" ; then kernel_cflags_iquote=-iquote kernel_cflags_iquote_end= @@ -15226,28 +16537,29 @@ $as_echo "$has_iquote" >&6; } CFLAGS="$save_cflags -Wl,--hash-style=sysv" CC="$aros_kernel_cc" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -Wl,--hash-style=sysv" >&5 -$as_echo_n "checking whether ${CC} accepts -Wl,--hash-style=sysv... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts -Wl,--hash-style=sysv" >&5 +printf %s "checking whether ${CC} accepts -Wl,--hash-style=sysv... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int -main () +main (void) { ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : use_hash_style="yes" -else +else $as_nop use_hash_style="no" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $use_hash_style" >&5 -$as_echo "$use_hash_style" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_hash_style" >&5 +printf "%s\n" "$use_hash_style" >&6; } if test "x-$use_hash_style" = "x-yes" ; then aros_kernel_cflags="$aros_kernel_cflags -Wl,--hash-style=sysv" fi @@ -15264,13 +16576,14 @@ CFLAGS="$save_cflags" -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for default resolution of WBScreen" >&5 -$as_echo_n "checking for default resolution of WBScreen... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for default resolution of WBScreen" >&5 +printf %s "checking for default resolution of WBScreen... " >&6; } # Check whether --with-resolution was given. -if test "${with_resolution+set}" = set; then : +if test ${with_resolution+y} +then : withval=$with_resolution; resolution=$withval -else +else $as_nop resolution=none fi @@ -15286,67 +16599,70 @@ if test "$resolution" != "none" ; then aros_nominal_height=`echo $resolution | cut -d'x' -f2` aros_nominal_depth=`echo $resolution | cut -d'x' -f3` fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&5 -$as_echo "$aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&5 +printf "%s\n" "$aros_nominal_width x $aros_nominal_height x $aros_nominal_depth" >&6; } aros_cv_nominal_width=$aros_nominal_width aros_cv_nominal_height=$aros_nominal_height aros_cv_nominal_depth=$aros_nominal_depth -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are compiling for non-vampires --with-nonvampire-support " >&5 -$as_echo_n "checking whether we are compiling for non-vampires --with-nonvampire-support ... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are compiling for non-vampires --with-nonvampire-support " >&5 +printf %s "checking whether we are compiling for non-vampires --with-nonvampire-support ... " >&6; } # Check whether --with-nonvampire-support was given. -if test "${with_nonvampire_support+set}" = set; then : +if test ${with_nonvampire_support+y} +then : withval=$with_nonvampire_support; nonvampire_support=$withval -else +else $as_nop nonvampire_support=none fi if test "$nonvampire_support" = "yes"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Enabling nonvampire support" >&5 -$as_echo "Enabling nonvampire support" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Enabling nonvampire support" >&5 +printf "%s\n" "Enabling nonvampire support" >&6; } aros_config_cppflags="$aros_config_cppflags -DNONVAMPIRE" aros_config_cflags="$aros_config_cflags -DNONVAMPIRE" aros_kernel_cppflags="$aros_kernel_cppflags -DNONVAMPIRE" aros_kernel_cflags="$aros_kernel_cflags -DNONVAMPIRE" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 -$as_echo_n "checking Vampire card series: v2 or v4 ... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Vampire card series: v2 or v4 " >&5 +printf %s "checking Vampire card series: v2 or v4 ... " >&6; } # Check whether --with-vampirecard-series was given. -if test "${with_vampirecard_series+set}" = set; then : +if test ${with_vampirecard_series+y} +then : withval=$with_vampirecard_series; vampirecard_series="$withval" -else +else $as_nop vampirecard_Series="v4" fi if test "$vampirecard_series" = "v2" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v2 " >&5 -$as_echo "Vampire Card Series v2 " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v2 " >&5 +printf "%s\n" "Vampire Card Series v2 " >&6; } aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=2" aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=2" aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=2" aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=2" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v4 " >&5 -$as_echo "Vampire Card Series v4 " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Vampire Card Series v4 " >&5 +printf "%s\n" "Vampire Card Series v4 " >&6; } aros_config_cppflags="$aros_config_cppflags -DVAMPIRECARDSERIES=4" aros_config_cflags="$aros_config_cflags -DVAMPIRECARDSERIES=4" aros_kernel_cppflags="$aros_kernel_cppflags -DVAMPIRECARDSERIES=4" aros_kernel_cflags="$aros_kernel_cflags -DVAMPIRECARDSERIES=4" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether serial debug is enabled" >&5 -$as_echo_n "checking whether serial debug is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether serial debug is enabled" >&5 +printf %s "checking whether serial debug is enabled... " >&6; } # Check whether --with-serial-debug was given. -if test "${with_serial_debug+set}" = set; then : +if test ${with_serial_debug+y} +then : withval=$with_serial_debug; serial_debug=$withval -else +else $as_nop serial_debug=none fi @@ -15364,34 +16680,36 @@ else fi if test "$serial_debug" != "none" ; then aros_serial_debug=$serial_debug - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $serial_debug_forced on port $serial_debug" >&5 -$as_echo "$serial_debug_forced on port $serial_debug" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $serial_debug_forced on port $serial_debug" >&5 +printf "%s\n" "$serial_debug_forced on port $serial_debug" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether palm debug hack is enabled" >&5 -$as_echo_n "checking whether palm debug hack is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether palm debug hack is enabled" >&5 +printf %s "checking whether palm debug hack is enabled... " >&6; } # Check whether --enable-palm_debug_hack was given. -if test "${enable_palm_debug_hack+set}" = set; then : +if test ${enable_palm_debug_hack+y} +then : enableval=$enable_palm_debug_hack; palm_debug_hack="yes" -else +else $as_nop palm_debug_hack="no" fi if test "$palm_debug_hack" = "yes" ; then aros_palm_debug_hack="1" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $palm_debug_hack" >&5 -$as_echo "$palm_debug_hack" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $palm_debug_hack" >&5 +printf "%s\n" "$palm_debug_hack" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether usb3.0 code is enabled" >&5 -$as_echo_n "checking whether usb3.0 code is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether usb3.0 code is enabled" >&5 +printf %s "checking whether usb3.0 code is enabled... " >&6; } # Check whether --enable-usb30_code was given. -if test "${enable_usb30_code+set}" = set; then : +if test ${enable_usb30_code+y} +then : enableval=$enable_usb30_code; usb30_code="yes" -else +else $as_nop usb30_code="no" fi @@ -15399,39 +16717,41 @@ if test "$usb30_code" = "yes" ; then aros_config_cppflags="$aros_config_cppflags -DAROS_USB30_CODE" aros_kernel_cflags="$aros_kernel_cflags -DAROS_USB30_CODE" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $usb30_code" >&5 -$as_echo "$usb30_code" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $usb30_code" >&5 +printf "%s\n" "$usb30_code" >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether nesting supervisor support is enabled" >&5 -$as_echo_n "checking whether nesting supervisor support is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether nesting supervisor support is enabled" >&5 +printf %s "checking whether nesting supervisor support is enabled... " >&6; } # Check whether --enable-nesting_supervisor was given. -if test "${enable_nesting_supervisor+set}" = set; then : +if test ${enable_nesting_supervisor+y} +then : enableval=$enable_nesting_supervisor; nesting_supervisor="yes" -else +else $as_nop nesting_supervisor="no" fi if test "$nesting_supervisor" = "yes" ; then aros_nesting_supervisor="1" fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $nesting_supervisor" >&5 -$as_echo "$nesting_supervisor" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $nesting_supervisor" >&5 +printf "%s\n" "$nesting_supervisor" >&6; } if test "$aros_enable_mmu" = "" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether MMU support is enabled" >&5 -$as_echo_n "checking whether MMU support is enabled... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether MMU support is enabled" >&5 +printf %s "checking whether MMU support is enabled... " >&6; } # Check whether --enable-mmu was given. -if test "${enable_mmu+set}" = set; then : +if test ${enable_mmu+y} +then : enableval=$enable_mmu; aros_enable_mmu=$enableval -else +else $as_nop aros_enable_mmu="yes" fi if test "$aros_enable_mmu" = "" ; then aros_enable_mmu="yes" fi - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $aros_enable_mmu" >&5 -$as_echo "$aros_enable_mmu" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $aros_enable_mmu" >&5 +printf "%s\n" "$aros_enable_mmu" >&6; } fi if test "$aros_enable_mmu" = "no" ; then aros_enable_mmu="0" @@ -15446,18 +16766,20 @@ if test "x-$aros_flavour" = "x-emulation" -o "x-$aros_flavour" = "x-emulcompat" save_libs="$LIBS" LIBS="" ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" -if test "x$ac_cv_func_dlopen" = xyes; then : +if test "x$ac_cv_func_dlopen" = xyes +then : have_dl="yes" -else +else $as_nop have_dl="no" fi if test "x-$have_dl" = "x-no" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 -$as_echo_n "checking for dlopen in -ldl... " >&6; } -if ${ac_cv_lib_dl_dlopen+:} false; then : - $as_echo_n "(cached) " >&6 -else + { 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 : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15466,33 +16788,32 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char dlopen (); int -main () +main (void) { return dlopen (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_dl_dlopen=yes -else +else $as_nop ac_cv_lib_dl_dlopen=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 -$as_echo "$ac_cv_lib_dl_dlopen" >&6; } -if test "x$ac_cv_lib_dl_dlopen" = xyes; then : +{ 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 : have_dl="yes" aros_host_ldflags="$aros_host_ldflags -ldl" -else +else $as_nop have_dl="no" fi @@ -15505,9 +16826,10 @@ fi # Check whether --enable-x11_hidd was given. -if test "${enable_x11_hidd+set}" = set; then : +if test ${enable_x11_hidd+y} +then : enableval=$enable_x11_hidd; x11_hidd="$enableval" -else +else $as_nop x11_hidd="$need_x11" fi @@ -15520,12 +16842,13 @@ fi if test "x-$x11_hidd" != "x-no" ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5 -$as_echo_n "checking for X... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for X" >&5 +printf %s "checking for X... " >&6; } # Check whether --with-x was given. -if test "${with_x+set}" = set; then : +if test ${with_x+y} +then : withval=$with_x; fi @@ -15536,12 +16859,41 @@ if test "x$with_x" = xno; then else case $x_includes,$x_libraries in #( *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #( - *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then : - $as_echo_n "(cached) " >&6 -else + *,NONE | NONE,*) if test ${ac_cv_have_x+y} +then : + printf %s "(cached) " >&6 +else $as_nop # One or both of the vars are not set, and there is no cached value. -ac_x_includes=no ac_x_libraries=no -rm -f -r conftest.dir +ac_x_includes=no +ac_x_libraries=no +# Do we need to do anything special at all? +ac_save_LIBS=$LIBS +LIBS="-lX11 $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main (void) +{ +XrmInitialize () + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO" +then : + # We can compile and link X programs with no special options. + ac_x_includes= + ac_x_libraries= +fi +rm -f core conftest.err conftest.$ac_objext conftest.beam \ + conftest$ac_exeext conftest.$ac_ext +LIBS="$ac_save_LIBS" +# If that didn't work, only try xmkmf and file system searches +# for native compilation. +if test x"$ac_x_includes" = xno && test "$cross_compiling" = no +then : + rm -f -r conftest.dir if mkdir conftest.dir; then cd conftest.dir cat >Imakefile <<'_ACEOF' @@ -15580,7 +16932,7 @@ _ACEOF rm -f -r conftest.dir fi -# Standard set of common directories for X headers. + # Standard set of common directories for X headers. # Check X11 before X11Rn because it is often a symlink to the current release. ac_x_header_dirs=' /usr/X11/include @@ -15607,6 +16959,8 @@ ac_x_header_dirs=' /usr/local/include/X11R5 /usr/local/include/X11R4 +/opt/X11/include + /usr/X386/include /usr/x386/include /usr/XFree86/include/X11 @@ -15628,10 +16982,11 @@ if test "$ac_x_includes" = no; then /* end confdefs.h. */ #include _ACEOF -if ac_fn_c_try_cpp "$LINENO"; then : +if ac_fn_c_try_cpp "$LINENO" +then : # We can compile using X headers with no special include directory. ac_x_includes= -else +else $as_nop for ac_dir in $ac_x_header_dirs; do if test -r "$ac_dir/X11/Xlib.h"; then ac_x_includes=$ac_dir @@ -15652,20 +17007,21 @@ if test "$ac_x_libraries" = no; then /* end confdefs.h. */ #include int -main () +main (void) { XrmInitialize () ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : LIBS=$ac_save_LIBS # We can link X programs with no special library path. ac_x_libraries= -else +else $as_nop LIBS=$ac_save_LIBS -for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` +for ac_dir in `printf "%s\n" "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g` do # Don't even attempt the hair of trying to link an X program! for ac_extension in a so sl dylib la dll; do @@ -15676,19 +17032,21 @@ do done done fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext fi # $ac_x_libraries = no +fi +# Record the results. case $ac_x_includes,$ac_x_libraries in #( - no,* | *,no | *\'*) + no,* | *,no | *\'*) : # Didn't find X, or a directory has "'" in its name. - ac_cv_have_x="have_x=no";; #( - *) + ac_cv_have_x="have_x=no" ;; #( + *) : # Record where we found X for the cache. ac_cv_have_x="have_x=yes\ ac_x_includes='$ac_x_includes'\ - ac_x_libraries='$ac_x_libraries'" + ac_x_libraries='$ac_x_libraries'" ;; esac fi ;; #( @@ -15698,8 +17056,8 @@ fi fi # $with_x != no if test "$have_x" != yes; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 -$as_echo "$have_x" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5 +printf "%s\n" "$have_x" >&6; } no_x=yes else # If each of the values was on the command line, it overrides each guess. @@ -15709,8 +17067,8 @@ else ac_cv_have_x="have_x=yes\ ac_x_includes='$x_includes'\ ac_x_libraries='$x_libraries'" - { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 -$as_echo "libraries $x_libraries, headers $x_includes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5 +printf "%s\n" "libraries $x_libraries, headers $x_includes" >&6; } fi @@ -15739,9 +17097,10 @@ fi aros_host_x11_ldflags="$X_LIBS -lX11" # Check whether --enable-x11_shm was given. -if test "${enable_x11_shm+set}" = set; then : +if test ${enable_x11_shm+y} +then : enableval=$enable_x11_shm; x11_hidd_shm="$enableval" -else +else $as_nop x11_hidd_shm="auto" fi @@ -15754,30 +17113,20 @@ fi if test "x-$x11_hidd_shm" != "x-no" ; then - for ac_header in sys/ipc.h -do : - ac_fn_c_check_header_mongrel "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" -if test "x$ac_cv_header_sys_ipc_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_IPC_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "sys/ipc.h" "ac_cv_header_sys_ipc_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_ipc_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_IPC_H 1" >>confdefs.h fi -done - - for ac_header in sys/shm.h -do : - ac_fn_c_check_header_mongrel "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" -if test "x$ac_cv_header_sys_shm_h" = xyes; then : - cat >>confdefs.h <<_ACEOF -#define HAVE_SYS_SHM_H 1 -_ACEOF + ac_fn_c_check_header_compile "$LINENO" "sys/shm.h" "ac_cv_header_sys_shm_h" "$ac_includes_default" +if test "x$ac_cv_header_sys_shm_h" = xyes +then : + printf "%s\n" "#define HAVE_SYS_SHM_H 1" >>confdefs.h fi -done - if test "x-$ac_cv_header_sys_ipc_h" = "x-yes" -a "x-$ac_cv_header_sys_shm_h" = "x-yes" ; then @@ -15785,11 +17134,12 @@ done save_ldflags="$LDFLAGS" CFLAGS="$CFLAGS $X_CFLAGS" LDFLAGS="$LDFLAGS $X_LIBS" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XShmQueryExtension in -lXext" >&5 -$as_echo_n "checking for XShmQueryExtension in -lXext... " >&6; } -if ${ac_cv_lib_Xext_XShmQueryExtension+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XShmQueryExtension in -lXext" >&5 +printf %s "checking for XShmQueryExtension in -lXext... " >&6; } +if test ${ac_cv_lib_Xext_XShmQueryExtension+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lXext $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15798,30 +17148,29 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char XShmQueryExtension (); int -main () +main (void) { return XShmQueryExtension (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_Xext_XShmQueryExtension=yes -else +else $as_nop ac_cv_lib_Xext_XShmQueryExtension=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xext_XShmQueryExtension" >&5 -$as_echo "$ac_cv_lib_Xext_XShmQueryExtension" >&6; } -if test "x$ac_cv_lib_Xext_XShmQueryExtension" = xyes; then : +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xext_XShmQueryExtension" >&5 +printf "%s\n" "$ac_cv_lib_Xext_XShmQueryExtension" >&6; } +if test "x$ac_cv_lib_Xext_XShmQueryExtension" = xyes +then : have_xshm=yes fi @@ -15840,9 +17189,10 @@ fi # Check whether --enable-x11_vidmode was given. -if test "${enable_x11_vidmode+set}" = set; then : +if test ${enable_x11_vidmode+y} +then : enableval=$enable_x11_vidmode; x11_hidd_vidmode="$enableval" -else +else $as_nop x11_hidd_vidmode="auto" fi @@ -15859,11 +17209,12 @@ fi save_ldflags="$LDFLAGS" CFLAGS="$CFLAGS $X_CFLAGS" LDFLAGS="$LDFLAGS $X_LIBS" - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryExtension in -lXxf86vm" >&5 -$as_echo_n "checking for XF86VidModeQueryExtension in -lXxf86vm... " >&6; } -if ${ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension+:} false; then : - $as_echo_n "(cached) " >&6 -else + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XF86VidModeQueryExtension in -lXxf86vm" >&5 +printf %s "checking for XF86VidModeQueryExtension in -lXxf86vm... " >&6; } +if test ${ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension+y} +then : + printf %s "(cached) " >&6 +else $as_nop ac_check_lib_save_LIBS=$LIBS LIBS="-lXxf86vm $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext @@ -15872,30 +17223,29 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ -#ifdef __cplusplus -extern "C" -#endif char XF86VidModeQueryExtension (); int -main () +main (void) { return XF86VidModeQueryExtension (); ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=yes -else +else $as_nop ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension=no fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&5 -$as_echo "$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&6; } -if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" = xyes; then : +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&5 +printf "%s\n" "$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" >&6; } +if test "x$ac_cv_lib_Xxf86vm_XF86VidModeQueryExtension" = xyes +then : have_vidmode=yes fi @@ -15914,9 +17264,10 @@ fi fi # Check whether --enable-sdl_hidd was given. -if test "${enable_sdl_hidd+set}" = set; then : +if test ${enable_sdl_hidd+y} +then : enableval=$enable_sdl_hidd; sdl_hidd="$enableval" -else +else $as_nop sdl_hidd="auto" fi @@ -15930,24 +17281,27 @@ fi SDL_VERSION=1.2.5 # Check whether --with-sdl-prefix was given. -if test "${with_sdl_prefix+set}" = set; then : +if test ${with_sdl_prefix+y} +then : withval=$with_sdl_prefix; sdl_prefix="$withval" -else +else $as_nop sdl_prefix="" fi # Check whether --with-sdl-exec-prefix was given. -if test "${with_sdl_exec_prefix+set}" = set; then : +if test ${with_sdl_exec_prefix+y} +then : withval=$with_sdl_exec_prefix; sdl_exec_prefix="$withval" -else +else $as_nop sdl_exec_prefix="" fi # Check whether --enable-sdltest was given. -if test "${enable_sdltest+set}" = set; then : +if test ${enable_sdltest+y} +then : enableval=$enable_sdltest; -else +else $as_nop enable_sdltest=yes fi @@ -15971,11 +17325,12 @@ fi fi # Extract the first word of "sdl-config", so it can be a program name with args. set dummy sdl-config; ac_word=$2 -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 -$as_echo_n "checking for $ac_word... " >&6; } -if ${ac_cv_path_SDL_CONFIG+:} false; then : - $as_echo_n "(cached) " >&6 -else +{ 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_SDL_CONFIG+y} +then : + printf %s "(cached) " >&6 +else $as_nop case $SDL_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_SDL_CONFIG="$SDL_CONFIG" # Let the user override the test with a path. @@ -15985,11 +17340,15 @@ else for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac 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_SDL_CONFIG="$as_dir/$ac_word$ac_exec_ext" - $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then + ac_cv_path_SDL_CONFIG="$as_dir$ac_word$ac_exec_ext" + printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5 break 2 fi done @@ -16002,18 +17361,18 @@ esac fi SDL_CONFIG=$ac_cv_path_SDL_CONFIG if test -n "$SDL_CONFIG"; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5 -$as_echo "$SDL_CONFIG" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SDL_CONFIG" >&5 +printf "%s\n" "$SDL_CONFIG" >&6; } else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } fi PATH="$as_save_PATH" min_sdl_version=$SDL_VERSION - { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SDL - version >= $min_sdl_version" >&5 -$as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SDL - version >= $min_sdl_version" >&5 +printf %s "checking for SDL - version >= $min_sdl_version... " >&6; } no_sdl="" if test "$SDL_CONFIG" = "no" ; then no_sdl=yes @@ -16035,9 +17394,10 @@ $as_echo_n "checking for SDL - version >= $min_sdl_version... " >&6; } CXXFLAGS="$CXXFLAGS $SDL_CFLAGS" LIBS="$LIBS $SDL_LIBS" rm -f conf.sdltest - if test "$cross_compiling" = yes; then : + if test "$cross_compiling" = yes +then : echo $ac_n "cross compiling; assumed OK... $ac_c" -else +else $as_nop cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -16099,9 +17459,10 @@ int main (int argc, char *argv[]) _ACEOF -if ac_fn_c_try_run "$LINENO"; then : +if ac_fn_c_try_run "$LINENO" +then : -else +else $as_nop no_sdl=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ @@ -16114,12 +17475,12 @@ fi fi fi if test "x$no_sdl" = x ; then - { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -$as_echo "yes" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } have_sdl="yes" else - { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 -$as_echo "no" >&6; } + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 +printf "%s\n" "no" >&6; } if test "$SDL_CONFIG" = "no" ; then echo "*** The sdl-config script installed by SDL could not be found" echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in" @@ -16145,14 +17506,15 @@ int main(int argc, char *argv[]) #define main K_and_R_C_main int -main () +main (void) { return 0; ; return 0; } _ACEOF -if ac_fn_c_try_link "$LINENO"; then : +if ac_fn_c_try_link "$LINENO" +then : echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding SDL or finding the wrong" echo "*** version of SDL. If it is not finding SDL, you'll need to set your" @@ -16162,13 +17524,13 @@ if ac_fn_c_try_link "$LINENO"; then : echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH" -else +else $as_nop echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occured. This usually means SDL was incorrectly installed" echo "*** or that you have moved SDL since it was installed. In the latter case, you" echo "*** may want to edit the sdl-config script: $SDL_CONFIG" fi -rm -f core conftest.err conftest.$ac_objext \ +rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext CFLAGS="$ac_save_CFLAGS" CXXFLAGS="$ac_save_CXXFLAGS" @@ -16200,12 +17562,13 @@ rm -f core conftest.err conftest.$ac_objext \ fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether building of dbus.library is enabled" >&5 -$as_echo_n "checking whether building of dbus.library is enabled... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether building of dbus.library is enabled" >&5 +printf %s "checking whether building of dbus.library is enabled... " >&6; } # Check whether --enable-dbus was given. -if test "${enable_dbus+set}" = set; then : +if test ${enable_dbus+y} +then : enableval=$enable_dbus; dbus="yes" -else +else $as_nop dbus="no" fi @@ -16218,8 +17581,8 @@ if test "$dbus" = "yes" ; then else ENABLE_DBUS=0 fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dbus" >&5 -$as_echo "$dbus" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dbus" >&5 +printf "%s\n" "$dbus" >&6; } if test "$use_kernel_cc_wrapper" = "yes" ; then aros_kernel_cc="${PWD}/${aros_tools_dir}/${aros_target_cpu}-${aros_target_arch}${aros_target_suffix}-elf-${toolchain_c_compiler}" @@ -16228,21 +17591,21 @@ fi aros_kernel_cppflags=$aros_config_cppflags aros_optimization_cflags="$optimization_level" if test "$optimization" = "default"; then -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking default optimization level to use" >&5 -$as_echo_n "checking default optimization level to use... " >&6; } -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $optimization_level" >&5 -$as_echo "$optimization_level" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking default optimization level to use" >&5 +printf %s "checking default optimization level to use... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $optimization_level" >&5 +printf "%s\n" "$optimization_level" >&6; } fi -{ $as_echo "$as_me:${as_lineno-$LINENO}: checking kernel optimization level to conserve space" >&5 -$as_echo_n "checking kernel optimization level to conserve space... " >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking kernel optimization level to conserve space" >&5 +printf %s "checking kernel optimization level to conserve space... " >&6; } if test "$kernel_optimization_level" = ""; then kernel_optimization_level=$optimization_level fi kernel_optimization_cflags="$kernel_optimization_level" -{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $kernel_optimization_level" >&5 -$as_echo "$kernel_optimization_level" >&6; } +{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $kernel_optimization_level" >&5 +printf "%s\n" "$kernel_optimization_level" >&6; } if ! test "$gcc_default_cpu" = "" ; then target_extra_cfg+="$export_newline""# ARM gcc default target$export_newline""GCC_DEFAULT_CPU := $gcc_default_cpu$export_newline""GCC_DEFAULT_FPU := $gcc_default_fpu$export_newline""GCC_DEFAULT_FLOAT_ABI := $gcc_default_float_abi$export_newline""GCC_DEFAULT_MODE := $gcc_default_mode$export_newline" @@ -16638,8 +18001,8 @@ _ACEOF case $ac_val in #( *${as_nl}*) case $ac_var in #( - *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 -$as_echo "$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) ;; #( @@ -16669,15 +18032,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; /^ac_cv_env_/b end t clear :clear - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 -$as_echo "$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 @@ -16691,8 +18054,8 @@ $as_echo "$as_me: updating cache $cache_file" >&6;} fi fi else - { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 -$as_echo "$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 @@ -16709,7 +18072,7 @@ U= for ac_i in : $LIBOBJS; 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=`$as_echo "$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" @@ -16725,8 +18088,8 @@ LTLIBOBJS=$ac_ltlibobjs ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 -$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +{ 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 #! $SHELL @@ -16749,14 +18112,16 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : +as_nop=: +if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 +then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else +else $as_nop case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( @@ -16766,46 +18131,46 @@ esac fi + +# Reset variables that may have inherited troublesome values from +# the environment. + +# IFS needs to be set, to space, tab, and newline, in precisely that order. +# (If _AS_PATH_WALK were called with IFS unset, it would have the +# side effect of setting IFS to empty, thus disabling word splitting.) +# Quoting is to prevent editors from complaining about space-tab. as_nl=' ' export as_nl -# Printing a long string crashes Solaris 7 /usr/bin/printf. -as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo -as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo -# Prefer a ksh shell builtin over an external printf program on Solaris, -# but without wasting forks for bash or zsh. -if test -z "$BASH_VERSION$ZSH_VERSION" \ - && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='print -r --' - as_echo_n='print -rn --' -elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then - as_echo='printf %s\n' - as_echo_n='printf %s' -else - if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then - as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' - as_echo_n='/usr/ucb/echo -n' - else - as_echo_body='eval expr "X$1" : "X\\(.*\\)"' - as_echo_n_body='eval - arg=$1; - case $arg in #( - *"$as_nl"*) - expr "X$arg" : "X\\(.*\\)$as_nl"; - arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; - esac; - expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" - ' - export as_echo_n_body - as_echo_n='sh -c $as_echo_n_body as_echo' - fi - export as_echo_body - as_echo='sh -c $as_echo_body as_echo' -fi +IFS=" "" $as_nl" + +PS1='$ ' +PS2='> ' +PS4='+ ' + +# Ensure predictable behavior from utilities with locale-dependent output. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# We cannot yet rely on "unset" to work, but we need these variables +# to be unset--not just set to an empty or harmless value--now, to +# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct +# also avoids known problems related to "unset" and subshell syntax +# in other old shells (e.g. bash 2.01 and pdksh 5.2.14). +for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH +do eval test \${$as_var+y} \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done + +# Ensure that fds 0, 1, and 2 are open. +if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi +if (exec 3>&2) ; then :; else exec 2>/dev/null; fi # The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then +if ${PATH_SEPARATOR+false} :; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || @@ -16814,13 +18179,6 @@ if test "${PATH_SEPARATOR+set}" != set; then fi -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -IFS=" "" $as_nl" - # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( @@ -16829,8 +18187,12 @@ case $0 in #(( for as_dir in $PATH do IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + case $as_dir in #((( + '') as_dir=./ ;; + */) ;; + *) as_dir=$as_dir/ ;; + esac + test -r "$as_dir$0" && as_myself=$as_dir$0 && break done IFS=$as_save_IFS @@ -16842,30 +18204,10 @@ if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then - $as_echo "$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 -# Unset variables that we do not need and which cause bugs (e.g. in -# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" -# suppresses any "Segmentation fault" message there. '((' could -# trigger a bug in pdksh 5.2.14. -for as_var in BASH_ENV ENV MAIL MAILPATH -do eval test x\${$as_var+set} = xset \ - && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -LC_ALL=C -export LC_ALL -LANGUAGE=C -export LANGUAGE - -# CDPATH. -(unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] @@ -16878,13 +18220,14 @@ 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 - $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi - $as_echo "$as_me: error: $2" >&2 + printf "%s\n" "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error + # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. @@ -16911,18 +18254,20 @@ as_fn_unset () { eval $1=; unset $1;} } as_unset=as_fn_unset + # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. -if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null +then : eval 'as_fn_append () { eval $1+=\$2 }' -else +else $as_nop as_fn_append () { eval $1=\$$1\$2 @@ -16934,12 +18279,13 @@ fi # as_fn_append # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. -if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null +then : eval 'as_fn_arith () { as_val=$(( $* )) }' -else +else $as_nop as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` @@ -16970,7 +18316,7 @@ as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X/"$0" | +printf "%s\n" X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q @@ -16992,6 +18338,10 @@ 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*) @@ -17005,6 +18355,12 @@ case `echo -n x` in #((((( 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_echo='printf %s\n' +as_echo_n='printf %s' + rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -17046,7 +18402,7 @@ as_fn_mkdir_p () as_dirs= while :; do case $as_dir in #( - *\'*) as_qdir=`$as_echo "$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" @@ -17055,7 +18411,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | +printf "%s\n" X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -17118,7 +18474,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # values after options handling. ac_log=" This file was extended by $as_me, which was -generated by GNU Autoconf 2.69. Invocation command line was +generated by GNU Autoconf 2.71. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -17180,14 +18536,16 @@ $config_commands Report bugs to the package provider." _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="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ config.status -configured by $0, generated by GNU Autoconf 2.69, +configured by $0, generated by GNU Autoconf 2.71, with options \\"\$ac_cs_config\\" -Copyright (C) 2012 Free Software Foundation, Inc. +Copyright (C) 2021 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -17224,15 +18582,15 @@ do -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - $as_echo "$ac_cs_version"; exit ;; + printf "%s\n" "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) - $as_echo "$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=`$as_echo "$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'" @@ -17240,7 +18598,7 @@ do --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in - *\'*) ac_optarg=`$as_echo "$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;; @@ -17249,7 +18607,7 @@ do as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) - $as_echo "$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=: ;; @@ -17277,7 +18635,7 @@ 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 - \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" @@ -17291,7 +18649,7 @@ exec 5>>config.log sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX - $as_echo "$ac_log" + printf "%s\n" "$ac_log" } >&5 _ACEOF @@ -17384,9 +18742,9 @@ done # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files - test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers - test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands + test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files + test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers + test ${CONFIG_COMMANDS+y} || CONFIG_COMMANDS=$config_commands fi # Have a temporary directory for convenience. Make it in the build tree @@ -17722,7 +19080,7 @@ do esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac - case $ac_f in *\'*) ac_f=`$as_echo "$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 @@ -17730,17 +19088,17 @@ do # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` - $as_echo "$*" | 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" - { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 -$as_echo "$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=`$as_echo "$configure_input" | + ac_sed_conf_input=`printf "%s\n" "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac @@ -17757,7 +19115,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$ac_file" | +printf "%s\n" X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q @@ -17781,9 +19139,9 @@ $as_echo X"$ac_file" | case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) - ac_dir_suffix=/`$as_echo "$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=`$as_echo "$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/ ;; @@ -17836,8 +19194,8 @@ ac_sed_dataroot=' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -$as_echo "$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 ac_datarootdir_hack=' @@ -17879,9 +19237,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"; } && - { $as_echo "$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 -$as_echo "$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" @@ -17897,27 +19255,27 @@ which seems to be undefined. Please make sure it is defined" >&2;} # if test x"$ac_file" != x-; then { - $as_echo "/* $configure_input */" \ + 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 - { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 -$as_echo "$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 - $as_echo "/* $configure_input */" \ + 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 ;; - :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 -$as_echo "$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 @@ -17992,8 +19350,8 @@ if test "$no_create" != yes; then $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 -$as_echo "$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 @@ -18006,3 +19364,4 @@ if test -n "$aros_shared_cflags" ; then echo "SHARED_AR := $aros_shared_ar" >> ${aros_hostcfg_dir}/host.cfg fi + diff --git a/distname b/distname index 3daa67ce5ed..97992fb230f 100644 --- a/distname +++ b/distname @@ -1 +1 @@ -ApolloROM \ No newline at end of file +ApolloOS \ No newline at end of file diff --git a/rebuild_all.sh b/rebuild_all.sh index 8d66a3315b4..a20a9fa9777 100755 --- a/rebuild_all.sh +++ b/rebuild_all.sh @@ -28,6 +28,7 @@ sleep 3 make clean git clean -df rm -rf bin/amiga-m68k +rm -rf config/features.status source ./make_dist_config.sh DISTOPTNAME="--enable-dist-name=${DISTRONAME}" @@ -38,6 +39,12 @@ DISTOPTVER="--enable-dist-version=${DISTROVERSION}" make -j${THREADS} make -j${THREADS} distfiles -cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > aros.rom -ls -lah aros.rom +if [ "${args[ 0 ]}" == "--with-nonvampire-support" ] +then + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.UAE + ls -lah ApolloROM.UAE +else + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.V4 + ls -lah ApolloROM.V4 +fi \ No newline at end of file diff --git a/rebuild_rom.sh b/rebuild_rom.sh index b358c8b93d8..928ec2fdde9 100755 --- a/rebuild_rom.sh +++ b/rebuild_rom.sh @@ -3,9 +3,9 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 4 ] +if [ ${THREADS} -gt 8 ] then - THREADS=4 + THREADS=8 fi args=("$@") @@ -28,6 +28,7 @@ sleep 3 make clean git clean -df rm -rf bin/amiga-m68k +rm -rf config/features.status source ./make_dist_config.sh @@ -38,6 +39,13 @@ DISTOPTVER="--enable-dist-version=${DISTROVERSION}" make -j${THREADS} make -j${THREADS} kernel-amiga-m68k -cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > aros.rom -ls -lah aros.rom + +if [ "${args[ 0 ]}" == "--with-nonvampire-support" ] +then + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.UAE + ls -lah ApolloROM.UAE +else + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.V4 + ls -lah ApolloROM.V4 +fi diff --git a/rebuild_rom_with_debug.sh b/rebuild_rom_with_debug.sh index 6ff7959cb42..32836b342ab 100755 --- a/rebuild_rom_with_debug.sh +++ b/rebuild_rom_with_debug.sh @@ -5,7 +5,7 @@ THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time if [ ${THREADS} -gt 8 ] then - THREADS=1 + THREADS=8 fi args=("$@") diff --git a/version b/version index 83afab86a74..4f7be4b1040 100755 --- a/version +++ b/version @@ -1 +1 @@ -Release 9.5-RC1 +Release 9.5-RC2 From 2931f8bd33cdbcde9344d0672b7e5089d432ffe6 Mon Sep 17 00:00:00 2001 From: WDrijver Date: Fri, 27 Dec 2024 18:12:54 +0100 Subject: [PATCH 5/5] ApolloOS R9.5-RC3 --- rebuild_all.sh | 8 ++++---- rebuild_all_quick.sh | 21 +++++++++++++++------ rebuild_rom.sh | 8 ++++---- rebuild_rom_quick.sh | 21 +++++++++++++++------ rebuild_rom_with_debug.sh | 20 ++++++++++++++------ rom/exec/taggedopenlibrary.c | 8 ++++---- 6 files changed, 56 insertions(+), 30 deletions(-) diff --git a/rebuild_all.sh b/rebuild_all.sh index a20a9fa9777..7484c666828 100755 --- a/rebuild_all.sh +++ b/rebuild_all.sh @@ -3,10 +3,10 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 8 ] -then - THREADS=8 -fi +#if [ ${THREADS} -gt 8 ] +#then +# THREADS=8 +#fi args=("$@") if [ "${args[ 0 ]}" == "-h" ] diff --git a/rebuild_all_quick.sh b/rebuild_all_quick.sh index 07056eb6999..f7727ea6950 100755 --- a/rebuild_all_quick.sh +++ b/rebuild_all_quick.sh @@ -3,10 +3,10 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 8 ] -then - THREADS=8 -fi +#if [ ${THREADS} -gt 8 ] +#then +# THREADS=8 +#fi args=("$@") if [ "${args[ 0 ]}" == "-h" ] @@ -25,7 +25,16 @@ if [ $# -gt 0 ]; then echo "# Building with $@"; fi echo "##############################################" sleep 3 +rm -rf config/features.status + make -j${THREADS} distfiles -cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > aros.rom -ls -lah aros.rom + +if [ "${args[ 0 ]}" == "--with-nonvampire-support" ] +then + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.UAE + ls -lah ApolloROM.UAE +else + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.V4 + ls -lah ApolloROM.V4 +fi diff --git a/rebuild_rom.sh b/rebuild_rom.sh index 928ec2fdde9..3e972d14de4 100755 --- a/rebuild_rom.sh +++ b/rebuild_rom.sh @@ -3,10 +3,10 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 8 ] -then - THREADS=8 -fi +#if [ ${THREADS} -gt 8 ] +#then +# THREADS=8 +#fi args=("$@") if [ "${args[ 0 ]}" == "-h" ] diff --git a/rebuild_rom_quick.sh b/rebuild_rom_quick.sh index d892f1940a1..7e6bd020507 100755 --- a/rebuild_rom_quick.sh +++ b/rebuild_rom_quick.sh @@ -3,10 +3,10 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 8 ] -then - THREADS=8 -fi +#if [ ${THREADS} -gt 8 ] +#then +# THREADS=8 +#fi args=("$@") if [ "${args[ 0 ]}" == "-h" ] @@ -23,7 +23,16 @@ echo "# Rebuilding with ${THREADS} parallel tasks" echo "##############################################" sleep 1 +rm -rf config/features.status + make -j${THREADS} kernel-amiga-m68k -cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > aros.rom -ls -lah aros.rom + +if [ "${args[ 0 ]}" == "--with-nonvampire-support" ] +then + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.UAE + ls -lah ApolloROM.UAE +else + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.V4 + ls -lah ApolloROM.V4 +fi diff --git a/rebuild_rom_with_debug.sh b/rebuild_rom_with_debug.sh index 32836b342ab..7db2a3a64ab 100755 --- a/rebuild_rom_with_debug.sh +++ b/rebuild_rom_with_debug.sh @@ -3,10 +3,10 @@ CPU_COUNT=$(grep processor /proc/cpuinfo | wc -l) THREADS=${CPU_COUNT} #Some how, running more than 8 tasks doesn't succeed every time -if [ ${THREADS} -gt 8 ] -then - THREADS=8 -fi +#if [ ${THREADS} -gt 8 ] +#then +# THREADS=8 +#fi args=("$@") if [ "${args[ 0 ]}" == "-h" ] @@ -29,6 +29,7 @@ sleep 3 make clean git clean -df rm -rf bin/amiga-m68k +rm -rf config/features.status DISTOPTNAME="--enable-dist-name=${DISTRONAME}" DISTOPTVER="--enable-dist-version=${DISTROVERSION}" @@ -39,6 +40,13 @@ source ./make_dist_config.sh make -j${THREADS} make -j${THREADS} kernel -cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > aros.rom -ls -lah aros.rom + +if [ "${args[ 0 ]}" == "--with-nonvampire-support" ] +then + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.UAE + ls -lah ApolloROM.UAE +else + cat bin/amiga-m68k/gen/boot/aros-amiga-m68k-ext.bin bin/amiga-m68k/gen/boot/aros-amiga-m68k-rom.bin > ApolloROM.V4 + ls -lah ApolloROM.V4 +fi diff --git a/rom/exec/taggedopenlibrary.c b/rom/exec/taggedopenlibrary.c index f663b835f40..984d8a500af 100644 --- a/rom/exec/taggedopenlibrary.c +++ b/rom/exec/taggedopenlibrary.c @@ -28,10 +28,10 @@ static const char * const libnames[] = static const char * const copyrights[] = { "AROS Research Operating System (AROS)", - "Copyright © 1995-2024, ", - "The AROS Development Team.", - "Other parts © by respective owners.", - "ALPHA ", + "ApolloOS created by Apollo Development Team ", + "Parts based on AROS Research Operating System (AROS) ", + "https://apollo-computer.com Copyright 1995-2025", + "APOLLO", MOD_NAME_STRING, "exec " MOD_VERS_STRING " (" MOD_DATE_STRING ")\r\n" };