libs/env-windows
libs/env-windows
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add BuildTools

Browse Source
This commit is contained in:
Meco Man 2022-09-13 22:50:14 -04:00
parent fedfb7ac07
commit 52b33b95f3
36 changed files with 9571 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
tools/BuildTools/2.12-20190422-1053/README.md Normal file
View File

@ -0,0 +1,46 @@
# GNU MCU Eclipse Windows Build Tools
The **GNU MCU Eclipse Windows Build Tools** subproject (formerly GNU ARM Eclipse Windows Build Tools) is a Windows specific package, customised for the requirements of the Eclipse CDT managed build projects. It includes a recent version of **GNU make** and a recent version of **BusyBox**, which provides a convenient implementation for `sh`/`rm`/`echo`.
## Easy install
The **GNU MCU Eclipse Windows Build Tools** are also available as a binary [xPack](https://www.npmjs.com/package/@gnu-mcu-eclipse/windows-build-tools) and can be conveniently installed with [xpm](https://www.npmjs.com/package/xpm):
```console
$ xpm install --global @gnu-mcu-eclipse/windows-build-tools
```
For more details on how to install the Windows Build Tools, please see [How to install the Windows Build Tools?](https://gnu-mcu-eclipse.github.io/windows-build-tools/install/) page.
## Changes
There are currently no changes from the official MSYS2 distribution or from the official BusyBox distribution.
## Compatibility
The binaries were built using [xPack Build Box (XBB)](https://github.com/xpack/xpack-build-box), a set of build environments based on slightly older systems that should be compatible with most recent systems.
- Windows: all binaries built with mingw-w64 GCC 7.4, running in a CentOS 6 Docker container.
## Build
The scripts used to build this distribution are in:
- `gnu-mcu-eclipse/scripts`
For the prerequisites and more details on the build procedure, please see the [How to build the Windows Build Tools binaries?](https://gnu-mcu-eclipse.github.io/windows-build-tools/build-procedure/) page.
## Documentation
The package does not include any documentation.
## More info
For more info and support, please see the GNU MCU Eclipse project pages from:
http://gnu-mcu-eclipse.github.io
Thank you for using **GNU MCU Eclipse**,
Liviu Ionescu

BIN
tools/BuildTools/2.12-20190422-1053/bin/busybox.exe Normal file
View File

Binary file not shown.

BIN
tools/BuildTools/2.12-20190422-1053/bin/echo.exe Normal file
View File

Binary file not shown.

BIN
tools/BuildTools/2.12-20190422-1053/bin/make.exe Normal file
View File

Binary file not shown.

BIN
tools/BuildTools/2.12-20190422-1053/bin/mkdir.exe Normal file
View File

Binary file not shown.

BIN
tools/BuildTools/2.12-20190422-1053/bin/rm.exe Normal file
View File

Binary file not shown.

BIN
tools/BuildTools/2.12-20190422-1053/bin/sh.exe Normal file
View File

Binary file not shown.

100
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/CHANGELOG.txt Normal file
View File

@ -0,0 +1,100 @@
Make
====
There are currently no changes from the official MSYS2 distribution.
BusyBox
=======
There are currently no changes from the official BusyBox distribution.
Build
=====
[2019-04-22]
- v2.12 released
[2019-04-06]
- prepare v2.12
- update build for XBB v2.1
- update to latest busybox rmyorston commit 65ae5b24cc08f898e81b36421b616fc7fc25d2b1
- fix the 32-bit build bug
[2018-04-28]
- v2.11 released
- build with the latest XBB scripts
- update to latest busybox rmyorston commit 6f7d1af269eed4b42daeb9c6dfd2ba62f9cd47e4
[2018-01-03]
- v2.10 released
- update to make 4.2.1
- update to latest busybox rmyorston commit 096aee2bb468d1ab044de36e176ed1f6c7e3674d
- no more setup.exe files
[2017-06-29]
- v2.9-20170629 released
- updated to rebranded helper
[2017-06-07]
- v2.9-20170607 released
- rebranded GNU MCU Eclipse
- use busybox rmyorston commit c2002eae394c230d6b89073c9ff71bc86a7875e8
[2016-11-22]
- v2.8-20161122 release
- mkdir.exe added, as a copy of busybox.exe
- use busybox rmyorston commit 9fa1e4990e655a85025c9d270a1606983e375e47
[2016-10-28]
- v2.7-20161028 released
- the NSIS script was fixed (add InstallDir) so silent install should honour /D
- try make 4.2, but build failed, it requires gettext-0.19.4, not available on Debian 8; stick with make 4.1
- use busybox rmyorston commit 977d65c1bbc57f5cdd0c8bfd67c8b5bb1cd390dd
[2015-07-16]
- v2.6-201507152002 released
[2015-05-14]
- v2.5 internal release
- the build script was updated to run under Docker.
- use make-4.1.3
- use busybox rmyorston commit ec39cb770ddd5c0e085d5c4ee10be65bab5e7a44
[2015-03-24]
- v2.4-201503242026 released
[2015-03-22]
- the NSIS script was fixed to prevent removing the keys when
uninstalling an older version.
[2015-03-21]
- v2.4-201503212005 released
[2015-01-25]
- v2.3-201501242223 released
[2015-01-24]
- v2.2-201501232303 released
[2015-01-22]
- v2.1-201501221704 released
Liviu Ionescu

183
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/busybox-w32/AUTHORS Normal file
View File

@ -0,0 +1,183 @@
List of the authors of code contained in BusyBox.
If you have code in BusyBox, you should be listed here. If you should be
listed, or the description of what you have done needs more detail, or is
incorrect, _please_ let me know.
-Erik
-----------
Peter Willis <psyphreak@phreaker.net>
eject
Emanuele Aina <emanuele.aina@tiscali.it>
run-parts
Erik Andersen <andersen@codepoet.org>
Tons of new stuff, major rewrite of most of the
core apps, tons of new apps as noted in header files.
Lots of tedious effort writing these boring docs that
nobody is going to actually read.
Laurence Anderson <l.d.anderson@warwick.ac.uk>
rpm2cpio, unzip, get_header_cpio, read_gz interface, rpm
Jeff Angielski <jeff@theptrgroup.com>
ftpput, ftpget
Enrik Berkhan <Enrik.Berkhan@inka.de>
setconsole
Jim Bauer <jfbauer@nfr.com>
modprobe shell dependency
Edward Betts <edward@debian.org>
expr, hostid, logname, whoami
John Beppu <beppu@codepoet.org>
du, nslookup, sort
David Brownell <dbrownell@users.sourceforge.net>
zcip
Brian Candler <B.Candler@pobox.com>
tiny-ls(ls)
Randolph Chung <tausq@debian.org>
fbset, ping, hostname
Dave Cinege <dcinege@psychosis.com>
more(v2), makedevs, dutmp, modularization, auto links file,
various fixes, Linux Router Project maintenance
Jordan Crouse <jordan@cosmicpenguin.net>
ipcalc
Magnus Damm <damm@opensource.se>
tftp client
insmod powerpc support
Larry Doolittle <ldoolitt@recycle.lbl.gov>
pristine source directory compilation, lots of patches and fixes.
Glenn Engel <glenne@engel.org>
httpd
Gennady Feldman <gfeldman@gena01.com>
Sysklogd (single threaded syslogd, IPC Circular buffer support,
logread), various fixes.
Robert Griebl <sandman@handhelds.org>
modprobe, hwclock, suid/sgid handling, tinylogin integration
many bugfixes and enhancements
Karl M. Hegbloom <karlheg@debian.org>
cp_mv.c, the test suite, various fixes to utility.c, &c.
Daniel Jacobowitz <dan@debian.org>
mktemp.c
Matt Kraai <kraai@alumni.cmu.edu>
documentation, bugfixes, test suite
Rob Landley <rob@landley.net>
Became busybox maintainer in 2006.
sed (major rewrite in 2003, and I now maintain the thing)
bunzip2 (complete from-scratch rewrite, then mjn3 optimized the result)
sort (more or less from scratch rewrite in 2004, I now maintain it)
mount (rewrite in 2005, I maintain the new one)
Stephan Linz <linz@li-pro.net>
ipcalc, Red Hat equivalence
John Lombardo <john@deltanet.com>
tr
Glenn McGrath <glenn.l.mcgrath@gmail.com>
Common unarchiving code and unarchiving applets, ifupdown, ftpgetput,
nameif, sed, patch, fold, install, uudecode.
Various bugfixes, review and apply numerous patches.
Manuel Novoa III <mjn3@codepoet.org>
cat, head, mkfifo, mknod, rmdir, sleep, tee, tty, uniq, usleep, wc, yes,
mesg, vconfig, nice, renice,
make_directory, parse_mode, dirname, mode_string,
get_last_path_component, simplify_path, and a number trivial libbb routines
also bug fixes, partial rewrites, and size optimizations in
ash, basename, cal, cmp, cp, df, du, echo, env, ln, logname, md5sum, mkdir,
mv, realpath, rm, sort, tail, touch, uname, watch, arith, human_readable,
interface, dutmp, ifconfig, route
Vladimir Oleynik <dzo@simtreas.ru>
cmdedit; bb_mkdep, xargs(current), httpd(current);
ports: ash, crond, fdisk (initial, unmaintained now), inetd, stty, traceroute,
top;
locale, various fixes
and irreconcilable critic of everything not perfect.
Bruce Perens <bruce@pixar.com>
Original author of BusyBox in 1995, 1996. Some of his code can
still be found hiding here and there...
Rodney Radford <rradford@mindspring.com>
ipcs, ipcrm
Tim Riker <Tim@Rikers.org>
bug fixes, member of fan club
Kent Robotti <robotti@metconnect.com>
reset, tons and tons of bug reports and patches.
Chip Rosenthal <chip@unicom.com>, <crosenth@covad.com>
wget - Contributed by permission of Covad Communications
Pavel Roskin <proski@gnu.org>
Lots of bugs fixes and patches.
Gyepi Sam <gyepi@praxis-sw.com>
Remote logging feature for syslogd
Rob Sullivan <cogito.ergo.cogito@gmail.com>
comm
Linus Torvalds
mkswap, fsck.minix, mkfs.minix
Linus Walleij
fbset and fbsplash config RGBA parsing
rewrite of mdev helper to create devices from /sys/dev
Mark Whitley <markw@codepoet.org>
grep, sed, cut, xargs(previous),
style-guide, new-applet-HOWTO, bug fixes, etc.
Charles P. Wright <cpwright@villagenet.com>
gzip, mini-netcat(nc)
Enrique Zanardi <ezanardi@ull.es>
tarcat (since removed), loadkmap, various fixes, Debian maintenance
Tito Ragusa <farmatito@tiscali.it>
devfsd and size optimizations in strings, openvt, chvt, deallocvt, hdparm,
fdformat, lsattr, chattr, id and eject.
Paul Fox <pgf@foxharp.boston.ma.us>
vi editing mode for ash, various other patches/fixes
Roberto A. Foglietta <me@roberto.foglietta.name>
port: dnsd
Bernhard Reutner-Fischer <rep.dot.nop@gmail.com>
misc
Mike Frysinger <vapier@gentoo.org>
initial e2fsprogs, printenv, setarch, sum, misc
Jie Zhang <jie.zhang@analog.com>
fixed two bugs in msh and hush (exitcode of killed processes)
Maxime Coste <mawww@kakoune.org>
paste implementation

348
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/busybox-w32/LICENSE Normal file
View File

@ -0,0 +1,348 @@
--- A note on GPL versions
BusyBox is distributed under version 2 of the General Public License (included
in its entirety, below). Version 2 is the only version of this license which
this version of BusyBox (or modified versions derived from this one) may be
distributed under.
------------------------------------------------------------------------
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

205
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/busybox-w32/README Normal file
View File

@ -0,0 +1,205 @@
Please see README.md for Windows-specific info.
Please see the LICENSE file for details on copying and usage.
Please refer to the INSTALL file for instructions on how to build.
What is busybox:
BusyBox combines tiny versions of many common UNIX utilities into a single
small executable. It provides minimalist replacements for most of the
utilities you usually find in bzip2, coreutils, dhcp, diffutils, e2fsprogs,
file, findutils, gawk, grep, inetutils, less, modutils, net-tools, procps,
sed, shadow, sysklogd, sysvinit, tar, util-linux, and vim. The utilities
in BusyBox often have fewer options than their full-featured cousins;
however, the options that are included provide the expected functionality
and behave very much like their larger counterparts.
BusyBox has been written with size-optimization and limited resources in
mind, both to produce small binaries and to reduce run-time memory usage.
Busybox is also extremely modular so you can easily include or exclude
commands (or features) at compile time. This makes it easy to customize
embedded systems; to create a working system, just add /dev, /etc, and a
Linux kernel. Busybox (usually together with uClibc) has also been used as
a component of "thin client" desktop systems, live-CD distributions, rescue
disks, installers, and so on.
BusyBox provides a fairly complete POSIX environment for any small system,
both embedded environments and more full featured systems concerned about
space. Busybox is slowly working towards implementing the full Single Unix
Specification V3 (http://www.opengroup.org/onlinepubs/009695399/), but isn't
there yet (and for size reasons will probably support at most UTF-8 for
internationalization). We are also interested in passing the Linux Test
Project (http://ltp.sourceforge.net).
----------------
Using busybox:
BusyBox is extremely configurable. This allows you to include only the
components and options you need, thereby reducing binary size. Run 'make
config' or 'make menuconfig' to select the functionality that you wish to
enable. (See 'make help' for more commands.)
The behavior of busybox is determined by the name it's called under: as
"cp" it behaves like cp, as "sed" it behaves like sed, and so on. Called
as "busybox" it takes the second argument as the name of the applet to
run (I.E. "./busybox ls -l /proc").
The "standalone shell" mode is an easy way to try out busybox; this is a
command shell that calls the built-in applets without needing them to be
installed in the path. (Note that this requires /proc to be mounted, if
testing from a boot floppy or in a chroot environment.)
The build automatically generates a file "busybox.links", which is used by
'make install' to create symlinks to the BusyBox binary for all compiled in
commands. This uses the CONFIG_PREFIX environment variable to specify
where to install, and installs hardlinks or symlinks depending
on the configuration preferences. (You can also manually run
the install script at "applets/install.sh").
----------------
Downloading the current source code:
Source for the latest released version, as well as daily snapshots, can always
be downloaded from
http://busybox.net/downloads/
You can browse the up to the minute source code and change history online.
http://git.busybox.net/busybox/
Anonymous GIT access is available. For instructions, check out:
http://www.busybox.net/source.html
For those that are actively contributing and would like to check files in,
see:
http://busybox.net/developer.html
The developers also have a bug and patch tracking system
(https://bugs.busybox.net) although posting a bug/patch to the mailing list
is generally a faster way of getting it fixed, and the complete archive of
what happened is the git changelog.
Note: if you want to compile busybox in a busybox environment you must
select CONFIG_DESKTOP.
----------------
Getting help:
when you find you need help, you can check out the busybox mailing list
archives at http://busybox.net/lists/busybox/ or even join
the mailing list if you are interested.
----------------
Bugs:
if you find bugs, please submit a detailed bug report to the busybox mailing
list at busybox@busybox.net. a well-written bug report should include a
transcript of a shell session that demonstrates the bad behavior and enables
anyone else to duplicate the bug on their own machine. the following is such
an example:
to: busybox@busybox.net
from: diligent@testing.linux.org
subject: /bin/date doesn't work
package: busybox
version: 1.00
when i execute busybox 'date' it produces unexpected results.
with gnu date i get the following output:
$ date
fri oct 8 14:19:41 mdt 2004
but when i use busybox date i get this instead:
$ date
illegal instruction
i am using debian unstable, kernel version 2.4.25-vrs2 on a netwinder,
and the latest uclibc from cvs.
-diligent
note the careful description and use of examples showing not only what
busybox does, but also a counter example showing what an equivalent app
does (or pointing to the text of a relevant standard). Bug reports lacking
such detail may never be fixed... Thanks for understanding.
----------------
Portability:
Busybox is developed and tested on Linux 2.4 and 2.6 kernels, compiled
with gcc (the unit-at-a-time optimizations in version 3.4 and later are
worth upgrading to get, but older versions should work), and linked against
uClibc (0.9.27 or greater) or glibc (2.2 or greater). In such an
environment, the full set of busybox features should work, and if
anything doesn't we want to know about it so we can fix it.
There are many other environments out there, in which busybox may build
and run just fine. We just don't test them. Since busybox consists of a
large number of more or less independent applets, portability is a question
of which features work where. Some busybox applets (such as cat and rm) are
highly portable and likely to work just about anywhere, while others (such as
insmod and losetup) require recent Linux kernels with recent C libraries.
Earlier versions of Linux and glibc may or may not work, for any given
configuration. Linux 2.2 or earlier should mostly work (there's still
some support code in things like mount.c) but this is no longer regularly
tested, and inherently won't support certain features (such as long files
and --bind mounts). The same is true for glibc 2.0 and 2.1: expect a higher
testing and debugging burden using such old infrastructure. (The busybox
developers are not very interested in supporting these older versions, but
will probably accept small self-contained patches to fix simple problems.)
Some environments are not recommended. Early versions of uClibc were buggy
and missing many features: upgrade. Linking against libc5 or dietlibc is
not supported and not interesting to the busybox developers. (The first is
obsolete and has no known size or feature advantages over uClibc, the second
has known bugs that its developers have actively refused to fix.) Ancient
Linux kernels (2.0.x and earlier) are similarly uninteresting.
In theory it's possible to use Busybox under other operating systems (such as
MacOS X, Solaris, Cygwin, or the BSD Fork Du Jour). This generally involves
a different kernel and a different C library at the same time. While it
should be possible to port the majority of the code to work in one of
these environments, don't be surprised if it doesn't work out of the box. If
you're into that sort of thing, start small (selecting just a few applets)
and work your way up.
In 2005 Shaun Jackman has ported busybox to a combination of newlib
and libgloss, and some of his patches have been integrated.
Supported hardware:
BusyBox in general will build on any architecture supported by gcc. We
support both 32 and 64 bit platforms, and both big and little endian
systems.
Under 2.4 Linux kernels, kernel module loading was implemented in a
platform-specific manner. Busybox's insmod utility has been reported to
work under ARM, CRIS, H8/300, x86, ia64, x86_64, m68k, MIPS, PowerPC, S390,
SH3/4/5, Sparc, and v850e. Anything else probably won't work.
The module loading mechanism for the 2.6 kernel is much more generic, and
we believe 2.6.x kernel module loading support should work on all
architectures supported by the kernel.
----------------
Please feed suggestions, bug reports, insults, and bribes back to the busybox
mailing list:
busybox@busybox.net
and/or maintainer:
Denys Vlasenko
<vda.linux@googlemail.com>

24
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/busybox-w32/README.md Normal file
View File

@ -0,0 +1,24 @@
### Status
Things may work for you, or may not. Things may never work because of huge differences between Linux and Windows. Or things may work in future, if you report the problem on [GitHub] (https://github.com/rmyorston/busybox-w32) or [GitLab] (https://gitlab.com/rmyorston/busybox-w32). If you don't have an account on one of those you can email me: [rmy@pobox.com] (mailto:rmy@pobox.com).
### Building
You need a MinGW compiler and a POSIX environment (so that `make menuconfig` works). I cross-compile on Linux. On Fedora or RHEL/CentOS+EPEL installing mingw32-gcc and mingw32-windows-default-manifest (32-bit build) or mingw64-gcc and mingw64-windows-default-manifest (64-bit build) will pull in everything needed.
To start, run `make mingw32_defconfig` or `make mingw64_defconfig`. You can then customize your build with `make menuconfig`.
In particular you may need to adjust the compiler by going to Busybox Settings -> Build Options -> Cross Compiler Prefix
Then just `make`.
### Limitations
- Use forward slashes in paths: Windows doesn't mind and the shell will be happier.
- Don't do wild things with Windows drive or UNC notation.
- Wildcard expansion is disabled by default, though it can be turned on at compile time. This only affects command line arguments to the binary: the BusyBox shell has full support for wildcards.
- Handling of users, groups and permissions is totally bogus. The system only admits to knowing about the current user and always returns the same hardcoded uid, gid and permission values.
- Some crufty old Windows code (Windows XP, cmd.exe) doesn't like forward slashes in environment variables. The -X shell option (which must be the first argument) prevents busybox-w32 from changing backslashes to forward slashes. If Windows programs don't run from the shell it's worth trying it.
- If you want to install 32-bit BusyBox in a system directory on a 64-bit version of Windows you should put it in `C:\Windows\SysWOW64`, not `C:\Windows\System32` as you might expect. On 64-bit systems the latter is for 64-bit binaries.
- ANSI escape sequences are emulated by converting to the equivalent in the Windows console API. Setting the environment variable `BB_SKIP_ANSI_EMULATION` will cause ANSI escapes to be passed to the console without emulation. This may be useful for Windows consoles that support ANSI escapes (e.g. ConEmu).
- It's possible to obtain pseudo-random numbers using `if=/dev/urandom` as the input file to `dd`. The same emulation of `/dev/urandom` is used internally by the `shred` utility and to support https in `wget`. Since the pseudo-random number generator isn't being seeded with sufficient entropy the randomness shouldn't be relied on for any serious use.

88
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/AUTHORS Normal file
View File

@ -0,0 +1,88 @@
-----------------------------------
GNU make development up to version 3.75 by:
Roland McGrath <roland@gnu.org>
Development starting with GNU make 3.76 by:
Paul D. Smith <psmith@gnu.org>
Additional development starting with GNU make 3.81 by:
Boris Kolpackov <boris@kolpackov.net>
GNU Make User's Manual
Written by:
Richard M. Stallman <rms@gnu.org>
Edited by:
Roland McGrath <roland@gnu.org>
Bob Chassell <bob@gnu.org>
Melissa Weisshaus <melissa@gnu.org>
Paul D. Smith <psmith@gnu.org>
-----------------------------------
GNU make porting efforts:
Port to VMS by:
Klaus Kaempf <kkaempf@progis.de>
Hartmut Becker <Hartmut.Becker@hp.com>
Archive support/Bug fixes by:
John W. Eaton <jwe@bevo.che.wisc.edu>
Martin Zinser <zinser@decus.decus.de>
Port to Amiga by:
Aaron Digulla <digulla@fh-konstanz.de>
Port to MS-DOS (DJGPP), OS/2, and MS-Windows (native/MinGW) by:
DJ Delorie <dj@delorie.com>
Rob Tulloh <rob_tulloh@tivoli.com>
Eli Zaretskii <eliz@gnu.org>
Jonathan Grant <jg@jguk.org>
Andreas Beuning <andreas.buening@nexgo.de>
Earnie Boyd <earnie@uses.sf.net>
Troy Runkel <Troy.Runkel@mathworks.com>
-----------------------------------
Other contributors:
Janet Carson <janet_carson@tivoli.com>
Howard Chu <hyc@highlandsun.com>
Ludovic Courtès <ludo@gnu.org>
Paul Eggert <eggert@twinsun.com>
Ramon Garcia Fernandez <ramon.garcia.f@gmail.com>
Klaus Heinz <kamar@ease.rhein-main.de>
Michael Joosten
Jim Kelton <jim_kelton@tivoli.com>
David Lubbren <uhay@rz.uni-karlsruhe.de>
Tim Magill <tim.magill@telops.gte.com>
Markus Mauhart <qwe123@chello.at>
Greg McGary <greg@mcgary.org>
Thien-Thi Nguyen <ttn@gnuvola.org>
Thomas Riedl <thomas.riedl@siemens.com>
Han-Wen Nienhuys <hanwen@cs.uu.nl>
Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
Carl Staelin (Princeton University)
Ian Stewartson (Data Logic Limited)
David A. Wheeler <dwheeler@dwheeler.com>
David Boyce <dsb@boyski.com>
Frank Heckenbach <f.heckenbach@fh-soft.de>
With suggestions/comments/bug reports from a cast of ... well ...
hundreds, anyway :)
-------------------------------------------------------------------------------
Copyright (C) 1997-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

674
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/COPYING Normal file
View File

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

1540
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/NEWS Normal file
View File

File diff suppressed because it is too large Load Diff

178
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README Normal file
View File

@ -0,0 +1,178 @@
This directory contains the 4.2.1 release of GNU Make.
See the file NEWS for the user-visible changes from previous releases.
In addition, there have been bugs fixed.
Please check the system-specific notes below for any caveats related to
your operating system.
For general building and installation instructions, see the file INSTALL.
If you need to build GNU Make and have no other 'make' program to use,
you can use the shell script 'build.sh' instead. To do this, first run
'configure' as described in INSTALL. Then, instead of typing 'make' to
build the program, type 'sh build.sh'. This should compile the program
in the current directory. Then you will have a Make program that you can
use for './make install', or whatever else.
Some systems' Make programs are broken and cannot process the Makefile for
GNU Make. If you get errors from your system's Make when building GNU
Make, try using 'build.sh' instead.
GNU Make is free software. See the file COPYING for copying conditions.
GNU Make is copyright by the Free Software Foundation. Copyright notices
condense sequential years into a range; e.g. "1987-1994" means all years
from 1987 to 1994 inclusive.
Downloading
-----------
GNU Make can be obtained in many different ways. See a description here:
http://www.gnu.org/software/software.html
Documentation
-------------
GNU make is fully documented in the GNU Make manual, which is contained
in this distribution as the file make.texinfo. You can also find
on-line and preformatted (PostScript and DVI) versions at the FSF's web
site. There is information there about ordering hardcopy documentation.
http://www.gnu.org/
http://www.gnu.org/doc/doc.html
http://www.gnu.org/manual/manual.html
Development
-----------
GNU Make development is hosted by Savannah, the FSF's online development
management tool. Savannah is here:
http://savannah.gnu.org
And the GNU Make development page is here:
http://savannah.gnu.org/projects/make/
You can find most information concerning the development of GNU Make at
this site.
Bug Reporting
-------------
You can send GNU make bug reports to <bug-make@gnu.org>. Please see the
section of the GNU make manual entitled 'Problems and Bugs' for
information on submitting useful and complete bug reports.
You can also use the online bug tracking system in the Savannah GNU Make
project to submit new problem reports or search for existing ones:
http://savannah.gnu.org/bugs/?group=make
If you need help using GNU make, try these forums:
help-make@gnu.org
help-utils@gnu.org
news:gnu.utils.help
news:gnu.utils.bug
Git Access
----------
The GNU make source repository is available via Git from the
GNU Savannah Git server; look here for details:
http://savannah.gnu.org/git/?group=make
Please note: you won't be able to build GNU make from Git without
installing appropriate maintainer's tools, such as GNU m4, automake,
autoconf, Perl, GNU make, and GCC. See the README.git file for hints on
how to build GNU make once these tools are available. We make no
guarantees about the contents or quality of the latest code in the Git
repository: it is not unheard of for code that is known to be broken to
be checked in. Use at your own risk.
System-specific Notes
---------------------
It has been reported that the XLC 1.2 compiler on AIX 3.2 is buggy such
that if you compile make with 'cc -O' on AIX 3.2, it will not work
correctly. It is said that using 'cc' without '-O' does work.
The standard /bin/sh on SunOS 4.1.3_U1 and 4.1.4 is broken and cannot be
used to configure GNU make. Please install a different shell such as
bash or pdksh in order to run "configure". See this message for more
information:
http://mail.gnu.org/archive/html/bug-autoconf/2003-10/msg00190.html
One area that is often a problem in configuration and porting is the code
to check the system's current load average. To make it easier to test and
debug this code, you can do 'make check-loadavg' to see if it works
properly on your system. (You must run 'configure' beforehand, but you
need not build Make itself to run this test.)
Another potential source of porting problems is the support for large
files (LFS) in configure for those operating systems that provide it.
Please report any bugs that you find in this area. If you run into
difficulties, then as a workaround you should be able to disable LFS by
adding the '--disable-largefile' option to the 'configure' script.
On systems that support micro- and nano-second timestamp values and
where stat(2) provides this information, GNU make will use it when
comparing timestamps to get the most accurate possible result. However,
note that many current implementations of tools that *set* timestamps do
not preserve micro- or nano-second granularity. This means that "cp -p"
and other similar tools (tar, etc.) may not exactly duplicate timestamps
with micro- and nano-second granularity on some systems. If your build
system contains rules that depend on proper behavior of tools like "cp
-p", you should consider using the .LOW_RESOLUTION_TIME pseudo-target to
force make to treat them properly. See the manual for details.
Ports
-----
- See README.customs for details on integrating GNU make with the
Customs distributed build environment from the Pmake distribution.
- See README.VMS for details about GNU Make on OpenVMS.
- See README.Amiga for details about GNU Make on AmigaDOS.
- See README.W32 for details about GNU Make on Windows NT, 95, or 98.
- See README.DOS for compilation instructions on MS-DOS and MS-Windows
using DJGPP tools.
A precompiled binary of the MSDOS port of GNU Make is available as part
of DJGPP; see the WWW page http://www.delorie.com/djgpp/ for more
information.
Please note there are two _separate_ ports of GNU make for Microsoft
systems: a native Windows tool built with (for example) MSVC or Cygwin,
and a DOS-based tool built with DJGPP. Please be sure you are looking
at the right README!
-------------------------------------------------------------------------------
Copyright (C) 1988-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

77
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.Amiga Normal file
View File

@ -0,0 +1,77 @@
Short: Port of GNU make with SAS/C (no ixemul.library required)
Author: GNU, Amiga port by Aaron "Optimizer" Digulla
Uploader: Aaron "Optimizer" Digulla (digulla@fh-konstanz.de)
Type: dev/c
This is a pure Amiga port of GNU make. It needs no extra libraries or
anything. It has the following features (in addition to any features of
GNU make):
- Runs Amiga-Commands with SystemTags() (Execute)
- Can run multi-line statements
- Allows to use Device-Names in targets:
c:make : make.o
is ok. To distinguish between device-names and target : or ::, MAKE
looks for spaces. If there are any around :, it's taken as a target
delimiter, if there are none, it's taken as the name of a device. Note
that "make:make.o" tries to create "make.o" on the device "make:".
- Replaces @@ by a newline in any command line:
if exists make @@\
delete make.bak quiet @@\
rename make make.bak @@\
endif @@\
$(CC) Link Make.o To make
works. Note that the @@ must stand alone (i.e., "make@@\" is illegal).
Also be careful that there is a space after the "\" (i.e., at the
beginning of the next line).
- Can be made resident to save space and time
- Amiga specific wildcards can be used in $(wildcard ...)
BUGS:
- The line
dummy.h : src/*.c
tries to make dummy.h from "src/*.c" (i.e., no wildcard-expansion takes
place). You have to use "$(wildcard src/*.c)" instead.
COMPILING FROM SCRATCH
----------------------
To recompile, you need SAS/C 6.51. make itself is not necessary, there
is an smakefile.
1. Copy config.ami to config.h
2. If you use make to compile, copy Makefile.ami to Makefile and
glob/Makefile.ami to glob/Makefile. Copy make into the current
directory.
3. Run smake/make
INSTALLATION
Copy make somewhere in your search path (e.g., sc:c or sc:bin).
If you plan to use recursive makes, install make resident:
Resident make Add
-------------------------------------------------------------------------------
Copyright (C) 1995-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

340
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.DOS Normal file
View File

@ -0,0 +1,340 @@
Port of GNU Make to 32-bit protected mode on MSDOS and MS-Windows.
Builds with DJGPP v2 port of GNU C/C++ compiler and utilities.
New (since 3.74) DOS-specific features:
1. Supports long filenames when run from DOS box on Windows 9x.
2. Supports both stock DOS COMMAND.COM and Unix-style shells
(details in 'Notes' below).
3. Supports DOS drive letters in dependencies and pattern rules.
4. Better support for DOS-style backslashes in pathnames (but see
'Notes' below).
5. The $(shell) built-in can run arbitrary complex commands,
including pipes and redirection, even when COMMAND.COM is your
shell.
6. Can be built without floating-point code (see below).
7. Supports signals in child programs and restores the original
directory if the child was interrupted.
8. Can be built without (a previous version of) Make.
9. The build process requires only standard tools. (Optional
targets like "install:" and "clean:" still need additional
programs, though, see below.)
10. Beginning with v3.78, the test suite works in the DJGPP
environment (requires Perl and auxiliary tools; see below).
To install a binary distribution:
Simply unzip the makNNNb.zip file (where NNN is the version number)
preserving the directory structure (-d switch if you use PKUNZIP).
If you are installing Make on Windows 9X or Windows 2000, use an
unzip program that supports long filenames in zip files. After
unzipping, make sure the directory with make.exe is on your PATH,
and that's all you need to use Make.
To build from sources:
1. Unzip the archive, preserving the directory structure (-d switch
if you use PKUNZIP). If you build Make on Windows 9X or Windows
2000, use an unzip program that supports long filenames in zip
files.
If you are unpacking an official GNU source distribution, use
either DJTAR (which is part of the DJGPP development
environment), or the DJGPP port of GNU Tar.
2. Invoke the 'configure.bat' batch file.
If you are building Make in-place, i.e. in the same directory
where its sources are kept, just type "configure.bat" and press
[Enter]. Otherwise, you need to supply the path to the source
directory as an argument to the batch file, like this:
c:\djgpp\gnu\make-4.2.1\configure.bat c:/djgpp/gnu/make-4.2.1
Note the forward slashes in the source path argument: you MUST
use them here.
3. If configure.bat doesn't find a working Make, it will suggest to
use the 'dosbuild.bat' batch file to build Make. Either do as it
suggests or install another Make program (a pre-compiled binary
should be available from the usual DJGPP sites) and rerun
configure.bat.
4. If you will need to run Make on machines without an FPU, you
might consider building a version of Make which doesn't issue
floating-point instructions (they don't help much on MSDOS
anyway). To this end, edit the Makefile created by
configure.bat and add -DNO_FLOAT to the value of CPPFLAGS.
5. Invoke Make.
If you are building from outside of the source directory, you
need to tell Make where the sources are, like this:
make srcdir=c:/djgpp/gnu/make-4.2.1
(configure.bat will tell you this when it finishes). You MUST
use a full, not relative, name of the source directory here, or
else Make might fail.
6. After Make finishes, if you have a Unix-style shell installed,
you can use the 'install' target to install the package. You
will also need GNU Fileutils and GNU Sed for this (they should
be available from the DJGPP sites).
By default, GNU make will install into your DJGPP installation
area. If you wish to use a different directory, override the
DESTDIR variable when invoking "make install", like this:
make install DESTDIR=c:/other/dir
This causes the make executable to be placed in c:/other/dir/bin,
the man pages in c:/other/dir/man, etc.
Without a Unix-style shell, you will have to install programs
and the docs manually. Copy make.exe to a directory on your
PATH, make.i* info files to your Info directory, and update the
file 'dir' in your Info directory by adding the following item
to the main menu:
* Make: (make.info). The GNU make utility.
If you have the 'install-info' program (from the GNU Texinfo
package), it will do that for you if you invoke it like this:
install-info --info-dir=c:/djgpp/info c:/djgpp/info/make.info
(If your Info directory is other than C:\DJGPP\INFO, change this
command accordingly.)
7. The 'clean' targets also require Unix-style shell, and GNU Sed
and 'rm' programs (the latter from Fileutils).
8. To run the test suite, type "make check". This requires a Unix
shell (I used the DJGPP port of Bash 2.03), Perl, Sed, Fileutils
and Sh-utils.
Notes:
-----
1. The shell issue.
This is probably the most significant improvement, first
introduced in the port of GNU Make 3.75.
The original behavior of GNU Make is to invoke commands
directly, as long as they don't include characters special to
the shell or internal shell commands, because that is faster.
When shell features like redirection or filename wildcards are
involved, Make calls the shell.
This port supports both DOS shells (the stock COMMAND.COM and its
4DOS/NDOS replacements), and Unix-style shells (tested with the
venerable Stewartson's 'ms_sh' 2.3 and the DJGPP port of 'bash' by
Daisuke Aoyama <jack@st.rim.or.jp>).
When the $SHELL variable points to a Unix-style shell, Make
works just like you'd expect on Unix, calling the shell for any
command that involves characters special to the shell or
internal shell commands. The only difference is that, since
there is no standard way to pass command lines longer than the
infamous DOS 126-character limit, this port of Make writes the
command line to a temporary disk file and then invokes the shell
on that file.
If $SHELL points to a DOS-style shell, however, Make will not
call it automatically, as it does with Unix shells. Stock
COMMAND.COM is too dumb and would unnecessarily limit the
functionality of Make. For example, you would not be able to
use long command lines in commands that use redirection or
pipes. Therefore, when presented with a DOS shell, this port of
Make will emulate most of the shell functionality, like
redirection and pipes, and shall only call the shell when a
batch file or a command internal to the shell is invoked. (Even
when a command is an internal shell command, Make will first
search the $PATH for it, so that if a Makefile calls 'mkdir',
you can install, say, a port of GNU 'mkdir' and have it called
in that case.)
The key to all this is the extended functionality of 'spawn' and
'system' functions from the DJGPP library; this port just calls
'system' where it would invoke the shell on Unix. The most
important aspect of these functions is that they use a special
mechanism to pass long (up to 16KB) command lines to DJGPP
programs. In addition, 'system' emulates some internal
commands, like 'cd' (so that you can now use forward slashes
with it, and can also change the drive if the directory is on
another drive). Another aspect worth mentioning is that you can
call Unix shell scripts directly, provided that the shell whose
name is mentioned on the first line of the script is installed
anywhere along the $PATH. It is impossible to tell here
everything about these functions; refer to the DJGPP library
reference for more details.
The $(shell) built-in is implemented in this port by calling
'popen'. Since 'popen' calls 'system', the above considerations
are valid for $(shell) as well. In particular, you can put
arbitrary complex commands, including pipes and redirection,
inside $(shell), which is in many cases a valid substitute for
the Unix-style command substitution (`command`) feature.
2. "SHELL=/bin/sh" -- or is it?
Many Unix Makefiles include a line which sets the SHELL, for
those versions of Make which don't have this as the default.
Since many DOS systems don't have 'sh' installed (in fact, most
of them don't even have a '/bin' directory), this port takes
such directives with a grain of salt. It will only honor such a
directive if the basename of the shell name (like 'sh' in the
above example) can indeed be found in the directory that is
mentioned in the SHELL= line ('/bin' in the above example), or
in the current working directory, or anywhere on the $PATH (in
that order). If the basename doesn't include a filename
extension, Make will look for any known extension that indicates
an executable file (.exe, .com, .bat, .btm, .sh, and even .sed
and .pl). If any such file is found, then $SHELL will be
defined to the exact pathname of that file, and that shell will
hence be used for the rest of processing. But if the named
shell is *not* found, the line which sets it will be effectively
ignored, leaving the value of $SHELL as it was before. Since a
lot of decisions that this port makes depend on the gender of
the shell, I feel it doesn't make any sense to tailor Make's
behavior to a shell which is nowhere to be found.
Note that the above special handling of "SHELL=" only happens
for Makefiles; if you set $SHELL in the environment or on the
Make command line, you are expected to give the complete
pathname of the shell, including the filename extension.
The default value of $SHELL is computed as on Unix (see the Make
manual for details), except that if $SHELL is not defined in the
environment, $COMSPEC is used. Also, if an environment variable
named $MAKESHELL is defined, it takes precedence over both
$COMSPEC and $SHELL. Note that, unlike Unix, $SHELL in the
environment *is* used to set the shell (since on MSDOS, it's
unlikely that the interactive shell will not be suitable for
Makefile processing).
The bottom line is that you can now write Makefiles where some
of the targets require a real (i.e. Unix-like) shell, which will
nevertheless work when such shell is not available (provided, of
course, that the commands which should always work, don't
require such a shell). More important, you can convert Unix
Makefiles to MSDOS and leave the line which sets the shell
intact, so that people who do have Unixy shell could use it for
targets which aren't converted to DOS (like 'install' and
'uninstall', for example).
3. Default directories.
GNU Make knows about standard directories where it searches for
library and include files mentioned in the Makefile. Since
MSDOS machines don't have standard places for these, this port
will search ${DJDIR}/lib and ${DJDIR}/include respectively.
$DJDIR is defined automatically by the DJGPP startup code as the
root of the DJGPP installation tree (unless you've tampered with
the DJGPP.ENV file). This should provide reasonable default
values, unless you moved parts of DJGPP to other directories.
4. Letter-case in filenames.
If you run Make on Windows 9x, you should be aware of the
letter-case issue. Make is internally case-sensitive, but all
file operations are case-insensitive on Windows 9x, so
e.g. files 'FAQ', 'faq' and 'Faq' all refer to the same file, as
far as Windows is concerned. The underlying DJGPP C library
functions honor the letter-case of the filenames they get from
the OS, except that by default, they down-case 8+3 DOS filenames
which are stored in upper case in the directory and would break
many Makefiles otherwise. (The details of which filenames are
converted to lower case are explained in the DJGPP libc docs,
under the '_preserve_fncase' and '_lfn_gen_short_fname'
functions, but as a thumb rule, any filename that is stored in
upper case in the directory, is a valid DOS 8+3 filename and
doesn't include characters invalid on MSDOS FAT filesystems,
will be automatically down-cased.) User reports that I have
indicate that this default behavior is generally what you'd
expect; however, your input is most welcome.
In any case, if you hit a situation where you must force Make to
get the 8+3 DOS filenames in upper case, set FNCASE=y in the
environment or in the Makefile.
5. DOS-style pathnames.
There are a lot of places throughout the program sources which
make implicit assumptions about the pathname syntax. In
particular, the directories are assumed to be separated by '/',
and any pathname which doesn't begin with a '/' is assumed to be
relative to the current directory. This port attempts to
support DOS-style pathnames which might include the drive letter
and use backslashes instead of forward slashes. However, this
support is not complete; I feel that pursuing this support too
far might break some more important features, particularly if
you use a Unix-style shell (where a backslash is a quote
character). I only consider support of backslashes desirable
because some Makefiles invoke non-DJGPP programs which don't
understand forward slashes. A notable example of such programs
is the standard programs which come with MSDOS. Otherwise, you
are advised to stay away from backslashes whenever possible. In
particular, filename globbing won't work on pathnames with
backslashes, because the GNU 'glob' library doesn't support them
(backslash is special in filename wildcards, and I didn't want
to break that).
One feature which *does* work with backslashes is the filename-
related built-in functions such as $(dir), $(notdir), etc.
Drive letters in pathnames are also fully supported.
Bug reports:
-----------
Bugs that are clearly related to the MSDOS/DJGPP port should be
reported first on the comp.os.msdos.djgpp news group (if you cannot
post to Usenet groups, write to the DJGPP mailing list,
<djgpp@delorie.com>, which is an email gateway into the above news
group). For other bugs, please follow the procedure explained in
the "Bugs" chapter of the Info docs. If you don't have an Info
reader, look up that chapter in the 'make.i1' file with any text
browser/editor.
Enjoy,
Eli Zaretskii <eliz@is.elta.co.il>
-------------------------------------------------------------------------------
Copyright (C) 1996-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

176
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.OS2 Normal file
View File

@ -0,0 +1,176 @@
Port of GNU make to OS/2.
Features of GNU make that do not work under OS/2:
- remote job execution
- dynamic load balancing
Special features of the OS/2 version:
Due to the fact that some people might want to use sh syntax in
Makefiles while others might want to use OS/2's native shell cmd.exe,
GNU make supports both shell types. The following list defines the order
that is used to determine the shell:
1. The shell specified by the environment variable MAKESHELL.
2. The shell specified by the SHELL variable within a Makefile. Like
Unix, SHELL is NOT taken from the environment.
3. The shell specified by the COMSPEC environment variable.
4. The shell specified by the OS2_SHELL environment variable.
5. If none of the above is defined /bin/sh is used as default. This
happens e.g. in the make testsuite.
Note: - Points 3 and 4 can be turned off at compile time by adding
-DNO_CMD_DEFAULT to the CPPFLAGS.
- DOS support is not tested for EMX and therefore might not work.
- The UNIXROOT environment variable is supported to find /bin/sh
if it is not on the current drive.
COMPILATION OF GNU MAKE FOR OS/2:
I. ***** SPECIAL OPTIONS *****
- At compile time you can turn off that cmd is used as default shell
(but only /bin/sh). Simply set CPPFLAGS="-DNO_CMD_DEFAULT" and make
will not use cmd unless you cause it to do so by setting MAKESHELL to
cmd or by specifying SHELL=cmd in your Makefile.
- At compile time you can set CPPFLAGS="-DNO_CHDIR2" to turn off that
GNU make prints drive letters. This is necessary if you want to run
the testsuite.
II. ***** REQUIREMENTS FOR THE COMPILATION *****
A standard Unix like build environment:
- sh compatible shell (ksh, bash, ash, but tested only with pdksh 5.2.14
release 2)
If you use pdksh it is recommended to update to 5.2.14 release 2. Older
versions may not work! You can get this version at
http://www.math.ohio-state.edu/~ilya/software/os2/pdksh-5.2.14-bin-2.zip
- GNU file utilities (make sure that install.exe from the file utilities
is in front of your PATH before X:\OS2\INSTALL\INSTALL.EXE. I recommend
also to change the filename to ginstall.exe instead of install.exe
to avoid confusion with X:\OS2\INSTALL\INSTALL.EXE)
- GNU shell utilities
- GNU text utilities
- gawk
- grep
- sed
- GNU make 3.79.1 (special OS/2 patched version) or higher
- perl 5.005 or higher
- GNU texinfo (you can use 3.1 (gnuinfo.zip), but I recommend 4.0)
If you want to recreate the configuration files (developers only!)
you need also: GNU m4 1.4, autoconf 2.59, automake 1.9.6 (or compatible)
III. ***** COMPILATION AND INSTALLATION *****
a) ** Developers only - Everyone else should skip this section **
To recreate the configuration files use:
export EMXSHELL=ksh
aclocal -I config
automake
autoconf
autoheader
b) Installation into x:/usr
Note: Although it is possible to compile make using "./configure",
"make", "make install" this is not recommended. In particular,
you must ALWAYS use LDFLAGS="-Zstack 0x6000" because the default
stack size is far to small and make will not work properly!
Recommended environment variables and installation options:
export ac_executable_extensions=".exe"
export CPPFLAGS="-D__ST_MT_ERRNO__"
export CFLAGS="-O2 -Zomf -Zmt"
export LDFLAGS="-Zcrtdll -Zlinker /exepack:2 -Zlinker /pm:vio -Zstack 0x6000"
export RANLIB="echo"
./configure --prefix=x:/usr --infodir=x:/usr/share/info --mandir=x:/usr/share/man --without-included-gettext
make AR=emxomfar
make install
Note: If you use gcc 2.9.x I recommend to set also LIBS="-lgcc"
Note: You can add -DNO_CMD_DEFAULT and -DNO_CHDIR2 to CPPFLAGS.
See section I. for details.
IV. ***** NLS support *****
GNU make has NLS (National Language Support), with the following
caveats:
a) It will only work with GNU gettext, and
b) GNU gettext support is not included in the GNU make package.
Therefore, if you wish to enable the internationalization features of
GNU make you must install GNU gettext on your system before configuring
GNU make.
You can choose the languages to be installed. To install support for
English, German and French only enter:
export LINGUAS="en de fr"
If you don't specify LINGUAS all languages are installed.
If you don't want NLS support (English only) use the option
--disable-nls for the configure script. Note if GNU gettext is not
installed then NLS will not be enabled regardless of this flag.
V. ***** Running the make test suite *****
To run the included make test suite you have to set
CPPFLAGS="-D__ST_MT_ERRNO__ -DNO_CMD_DEFAULT -DNO_CHDIR2"
before you compile make. This is due to some restrictions of the
testsuite itself. -DNO_CMD_DEFAULT causes make to use /bin/sh as default
shell in every case. Normally you could simply set MAKESHELL="/bin/sh"
to do this but the testsuite ignores the environment. -DNO_CHDIR2 causes
make not to use drive letters for directory names (i.e. _chdir2() and
_getcwd2() are NOT used). The testsuite interpretes the whole output of
make, especially statements like make[1]: Entering directory
'C:/somewhere/make-3.79.1/tests' where the testsuite does not expect the
drive letter. This would be interpreted as an error even if there is
none.
To run the testsuite do the following:
export CPPFLAGS="-D__ST_MT_ERRNO__ -DNO_CMD_DEFAULT -DNO_CHDIR2"
export CFLAGS="-Zomf -O2 -Zmt"
export LDFLAGS="-Zcrtdll -s -Zlinker /exepack:2 -Zlinker /pm:vio -Zstack 0x6000"
export RANLIB="echo"
./configure --prefix=x:/usr --disable-nls
make AR=emxomfar
make check
All tests should work fine with the exception of one of the "INCLUDE_DIRS"
tests which will fail if your /usr/include directory is on a drive different
from the make source tree.
-------------------------------------------------------------------------------
Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

515
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.VMS Normal file
View File

@ -0,0 +1,515 @@
Overview: -*-text-mode-*-
---------
This version of GNU make has been tested on:
OpenVMS V8.3/V8.4 (Alpha) and V8.4 (Integrity) AND V7.3 (VAX)
This version of GNU Make is intended to be run from DCL to run
make scripts with a special syntax that is described below. It
likely will not be able to run unmodified Unix makefiles.
There is an older implementation of GNU Make that was ported to GNV.
Work is now in progress to merge that port to get a single version
of GNU Make available. When that merge is done, GNU Make will auto
detect that it is running under a Posix shell and then operate as close to
GNU Make on Unix as possible.
The descriptions below are for running GNU make from DCL or equivalent.
Recipe differences:
-------------------
GNU Make for OpenVMS can not currently run native Unix make files because of
differences in the implementation.
I am trying to document the current behavior in this section. This is based
on the information in the file NEWS. and running the test suite.
TODO: More tests are needed to validate and demonstrate the OpenVMS
expected behavior.
In some cases the older behavior of GNU Make when run from DCL is not
compatible with standard makefile behavior.
This behavior can be changed when running GNU Make from DCL by setting
either DCL symbols or logical names of the format GNV$. The settings
are enabled with a string starting with one of '1', 'T', or 'E' for "1",
"TRUE", or "ENABLE". They are disabled with a '0', 'F', or 'D' for "1",
"FALSE", or "DISABLE". If they are not explicitly set to one of these
values, then they will be set to their default values.
The value of the setting DECC$FILENAME_UNIX_REPORT or
DECC$FILENAME_UNIX_ONLY will now cause the $(dir x) function to return
'./' or '[]' as appropriate.
The name GNV$MAKE_OLD_VMS when enabled will cause GNU Make to behave as
much as the older method as can be done with out disabling VMS features.
When it is disabled GNU Make have the new behavior which more closely
matches Unix Make behavior.
The default is currently the old behavior when running GNU Make from DCL.
In the future this may change. When running make from GNV Bash the new
behavior is the default.
This is a global setting that sets the default behavior for several other
options that can be individually changed. Many of the individual settings
are to make it so that the self tests for GNU Make need less VMS specific
modifications.
The name GNV$MAKE_COMMA when enabled will cause GNU Make to expect a comma
for a path separator and use a comma for the separator for a list of files.
When disabled, it will cause GNU Make to use a colon for a path separator
and a space for the separator for a list of files. The default is to be
enabled if the GNU Make is set to the older behavior.
The name GNV$MAKE_SHELL_SIM when enabled will cause GNU Make to try to
simulate a Posix shell more closely. The following behaviors occur:
* Single quotes are converted to double quotes and any double
quotes inside of them are doubled. No environment variable expansion
is simulated.
* A exit command status will be converted to a Posix Exit
where 0 is success and non-zero is failure.
* The $ character will cause environment variable expansion.
* Environent variables can be set on the command line before a command.
VMS generally uses logical name search lists instead of path variables
where the resolution is handled by VMS independent of the program. Which
means that it is likely that nothing will notice if the default path
specifier is changed in the future.
Currently the built in VMS specific macros and recipes depend on the comma
being used as a file list separator.
TODO: Remove this dependency as other functions in GNU Make depend on a
space being used as a separator.
The format for recipes are a combination of Unix macros, a subset of
simulated UNIX commands, some shell emulation, and OpenVMS commands.
This makes the resulting makefiles unique to the OpenVMS port of GNU make.
If you are creating a OpenVMS specific makefile from scratch, you should also
look at MMK (Madgoat Make) available at https://github.com/endlesssoftware/mmk
MMK uses full OpenVMS syntax and a persistent subprocess is used for the
recipe lines, allowing multiple line rules.
The default makefile search order is "makefile.vms", "gnumakefile",
"makefile". TODO: See if that lookup is case sensitive.
When Make is invoked from DCL, it will create a foreign command
using the name of executable image, with any facility prefix removed,
for the duration of the make program, so it can be used internally
to recursively run make(). The macro MAKE_COMMAND will be set to
this foreign command.
When make is launched from an exec*() command from a C program,
the foreign command is not created. The macro MAKE_COMMAND will be
set to the actual command passed as argv[0] to the exec*() function.
If the DCL symbol or logical name GNV$MAKE_USE_MCR exists, then
the macro MAKE_COMMAND will be set to be an "MCR" command with the
absolute path used by DCL to launch make. The foreign command
will not be created.
The macro MAKE is set to be the same value as the macro MAKE_COMMAND
on all platforms.
Each recipe command is normally run as a separate spawned processes,
except for the cases documented below where a temporary DCL command
file may be used.
BUG: Testing has shown that the commands in the temporary command files
are not always created properly. This issue is still under investigation.
Any macros marked as exported are temporarily created as DCL symbols
for child images to use. DCL symbol substitution is not done with these
commands.
Untested: Symbol substitution.
When a temporary DCL command file is used, DCL symbol substitution
will work.
For VMS 7.3-1 and earlier, command lines are limited to 255 characters
or 1024 characters in a command file.
For VMS 7.3-2 and later, command lines are limited to 4059 characters
or 8192 characters in a command file.
VMS limits each token of a command line to 256 characters, and limits
a command line to 127 tokens.
Command lines above the limit length are written to a command file
in sys$scratch:.
In order to handle Unix style extensions to VMS DCL, GNU Make has
parsed the recipe commands and them modified them as needed. The
parser has been re-written to resolve numerous bugs in handling
valid VMS syntax and potential buffer overruns.
The new parser may need whitespace characters where DCL does not require
it, and also may require that quotes are matched were DCL forgives if
they are not. There is a small chance that existing VMS specific makefiles
will be affected.
The '<', '>' was previously implemented using command files. Now
GNU Make will check to see if the is already a VMS "PIPE" command and
if it is not, will convert the command to a VMS "PIPE" command.
The '>>' redirection has been implemented by using a temporary command file.
This will be described later.
The DCL symbol or logical name GNV$MAKE_USE_CMD_FILE when set to a
string starting with one of '1','T', or 'E' for "1", "TRUE", or "ENABLE",
then temporary DCL command files are always used for running commands.
Some recipe strings with embedded new lines will not be handled correctly
when a command file is used.
GNU Make generally does text comparisons for the targets and sources. The
make program itself can handle either Unix or OpenVMS format filenames, but
normally does not do any conversions from one format to another.
TODO: The OpenVMS format syntax handling is incomplete.
TODO: ODS-5 EFS support is missing.
BUG: The internal routines to convert filenames to and from OpenVMS format
do not work correctly.
Note: In the examples below, line continuations such as a backslash may have
been added to make the examples easier to read in this format.
BUG: That feature does not completely work at this time.
Since the OpenVMS utilities generally expect OpenVMS format paths, you will
usually have to use OpenVMS format paths for rules and targets.
BUG: Relative OpenVMS paths may not work in targets, especially combined
with vpaths. This is because GNU make will just concatenate the directories
as it does on Unix.
The variables $^ and $@ separate files with commas instead of spaces.
This is controlled by the name GNV$MAKE_COMMA as documented in the
previous section.
While this may seem the natural thing to do with OpenVMS, it actually
causes problems when trying to use other make functions that expect the
files to be separated by spaces. If you run into this, you need the
following workaround to convert the output.
TODO: Look at have the $^ and $@ use spaces like on Unix and have
and easy to use function to do the conversions and have the built
in OpenVMS specific recipes and macros use it.
Example:
comma := ,
empty :=
space := $(empty) $(empty)
foo: $(addsuffix .3,$(subs $(comma),$(space),$^)
Makefile variables are looked up in the current environment. You can set
symbols or logicals in DCL and evaluate them in the Makefile via
$(<name-of-symbol-or-logical>). Variables defined in the Makefile
override OpenVMS symbols/logicals.
OpenVMS logical and symbols names show up as "environment" using the
origin function. when the "-e" option is specified, the origion function
shows them as "environment override". On Posix the test scripts indicate
that they should show up just as "environment".
When GNU make reads in a symbol or logical name into the environment, it
converts any dollar signs found to double dollar signs for convenience in
using DCL symbols and logical names in recipes. When GNU make exports a
DCL symbol for a child process, if the first dollar sign found is followed
by second dollar sign, then all double dollar signs will be convirted to
single dollar signs.
The variable $(ARCH) is predefined as IA64, ALPHA or VAX respectively.
Makefiles for different OpenVMS systems can now be written by checking
$(ARCH). Since IA64 and ALPHA are similar, usually just a check for
VAX or not VAX is sufficient.
You may have to update makefiles that assume VAX if not ALPHA.
ifeq ($(ARCH),VAX)
$(ECHO) "On the VAX"
else
$(ECHO) "On the ALPHA or IA64"
endif
Empty commands are handled correctly and don't end in a new DCL process.
The exit command needs to have OpenVMS exit codes. To pass a Posix code
back to the make script, you need to encode it by multiplying it by 8
and then adding %x1035a002 for a failure code and %x1035a001 for a
success. Make will interpret any posix code other than 0 as a failure.
TODO: Add an option have simulate Posix exit commands in recipes.
Lexical functions can be used in pipes to simulate shell file test rules.
Example:
Posix:
b : c ; [ -f $@ ] || echo >> $@
OpenVMS:
b : c ; if f$$search("$@") then pipe open/append xx $@ ; write xx "" ; close xx
You can also use pipes and turning messages off to silently test for a
failure.
x = %x1035a00a
%.b : %.c
<tab>pipe set mess/nofac/noiden/nosev/notext ; type $^/output=$@ || exit $(x)
Runtime issues:
The OpenVMS C Runtime has a convention for encoding a Posix exit status into
to OpenVMS exit codes. These status codes will have the hex value of
0x35a000. OpenVMS exit code may also have a hex value of %x10000000 set on
them. This is a flag to tell DCL not to write out the exit code.
To convert an OpenVMS encoded Posix exit status code to the original code
You subtract %x35a000 and any flags from the OpenVMS code and divide it by 8.
WARNING: Backward-incompatibility!
The make program exit now returns the same encoded Posix exit code as on
Unix. Previous versions returned the OpenVMS exit status code if that is what
caused the recipe to fail.
TODO: Provide a way for scripts calling make to obtain that OpenVMS status
code.
Make internally has two error codes, MAKE_FAILURE and MAKE_TROUBLE. These
will have the error "-E-" severity set on exit.
MAKE_TROUBLE is returned only if the option "-q" or "--question" is used and
has a Posix value of 1 and an OpenVMS status of %x1035a00a.
MAKE_FAILURE has a Posix value of 2 and an OpenVMS status of %x1035a012.
Output from GNU make may have single quotes around some values where on
other platforms it does not. Also output that would be in double quotes
on some platforms may show up as single quotes on VMS.
There may be extra blank lines in the output on VMS.
https://savannah.gnu.org/bugs/?func=detailitem&item_id=41760
There may be a "Waiting for unfinished jobs..." show up in the output.
Error messages generated by Make or Unix utilities may slightly vary from
Posix platforms. Typically the case may be different.
When make deletes files, on posix platforms it writes out 'rm' and the list
of files. On VMS, only the files are writen out, one per line.
TODO: VMS
There may be extra leading white space or additional or missing whitespace
in the output of recipes.
GNU Make uses sys$scratch: for the tempfiles that it creates.
The OpenVMS CRTL library maps /tmp to sys$scratch if the TMP: logical name
does not exist. As the CRTL may use both sys$scratch: and /tmp internally,
if you define the TMP logical name to be different than SYS$SCRATCH:,
you may end up with only some temporary files in TMP: and some in SYS$SCRATCH:
The default include directory for including other makefiles is
SYS$SYSROOT:[SYSLIB] (I don't remember why I didn't just use
SYS$LIBRARY: instead; maybe it wouldn't work that way).
TODO: A better default may be desired.
If the device for a file in a recipe does not exist, on OpenVMS an error
message of "stat: <file>: no such device or address" will be output.
Make ignores success, informational, or warning errors (-S-, -I-, or
-W-). But it will stop on -E- and -F- errors. (unless you do something
to override this in your makefile, or whatever).
Unix compatibilty features:
---------------------------
If the command 'echo' is seen, any single quotes on the line will be
converted to double quotes.
The variable $(CD) is implemented as a built in Change Directory
command. This invokes the 'builtin_cd' Executing a 'set default'
recipe doesn't do the trick, since it only affects the subprocess
spawned for that command.
The 'builtin_cd' is generally expected to be on its own line.
The 'builtin_cd' either from the expansion of $(CD) or directly
put in a recipe line will be executed before any other commands in
that recipe line. DCL parameter substitution will not work for the
'builtin_cd' command.
Putting a 'builtin_cd' in a pipeline or an IF-THEN line should not be
done because the 'builtin_cd' is always executed
and executed first. The directory change is persistent.
Unix shell style I/O redirection is supported. You can now write lines like:
"<tab>mcr sys$disk:[]program.exe < input.txt > output.txt &> error.txt"
Posix shells have ":" as a null command. These are now handled.
https://savannah.gnu.org/bugs/index.php?41761
A note on appending the redirected output. A simple mechanism is
implemented to make ">>" work in action lines. In OpenVMS there is no simple
feature like ">>" to have DCL command or program output redirected and
appended to a file. GNU make for OpenVMS implements the redirection
of ">>" by using a command procedure.
The current algorithm creates the output file if it does not exist and
then uses the DCL open/append to extend it. SYS$OUTPUT is then directed
to that file.
The implementation supports only one redirected append output to a file
and that redirection is done before any other commands in that line
are executed, so it redirects all output for that command.
The older implementation wrote the output to a temporary file in
in sys$scratch: and then attempted to append the file to the existing file.
The temporary file names looked like "CMDxxxxx.". Any time the created
command procedure can not complete, this happens. Pressing Ctrl+Y to
abort make is one case.
In case of Ctrl+Y the associated command procedure is left in SYS$SCRATCH:.
The command procedures will be named gnv$make_cmd*.com.
The CtrlY handler now uses $delprc to delete all children. This way also
actions with DCL commands will be stopped. As before the CtrlY handler
then sends SIGQUIT to itself, which is handled in common code.
Temporary command files are now deleted in the OpenVMS child termination
handler. That deletes them even if a Ctrl+C was pressed.
TODO: Does the previous section about >> leaving files still apply?
The behavior of pressing Ctrl+C is not changed. It still has only an effect,
after the current action is terminated. If that doesn't happen or takes too
long, Ctrl+Y should be used instead.
Build Options:
Added support to have case sensitive targets and dependencies but to
still use case blind file names. This is especially useful for Java
makefiles on VMS:
<TAB>.SUFFIXES :
<TAB>.SUFFIXES : .class .java
<TAB>.java.class :
<TAB><TAB>javac "$<"
<TAB>HelloWorld.class : HelloWorld.java
A new macro WANT_CASE_SENSITIVE_TARGETS in config.h-vms was introduced.
It needs to be enabled to get this feature; default is disabled.
TODO: This should be a run-time setting based on if the process
has been set to case sensitive.
Unimplemented functionality:
The new feature "Loadable objects" is not yet supported. If you need it,
please send a change request or submit a bug report.
The new option --output-sync (-O) is accepted but has no effect: GNU make
for OpenVMS does not support running multiple commands simultaneously.
Self test failures and todos:
-----------------------------
The test harness can not handle testing some of the VMS specific modes
because of the features needed for to be set for the Perl to run.
Need to find a way to set the VMS features before running make as a
child.
GNU make was not currently translating the OpenVMS encoded POSIX values
returned to it back to the Posix values. I have temporarily modified the
Perl test script to compensate for it. This should be being handled
internally to Make.
TODO: Verify and update the Perl test script.
The features/parallelism test was failing. OpenVMS is executing the rules
in sequence not in parallel as this feature was not implemented.
GNU Make on VMS no longer claims it is implemented.
TODO: Implement it.
Symlink support is not present. Symlinks are supported by OpenVMS 8.3 and
later.
Error messages should be supressed with the "-" at the beginning of a line.
On openVMS they were showing up. TODO: Is this still an issue?
The internal vmsify and unixify OpenVMS to/from UNIX are not handling logical
names correctly.
Build instructions:
------------------
Don't use the HP C V7.2-001 compiler, which has an incompatible change
how __STDC__ is defined. This results at least in compile time warnings.
Make a 1st version
$ @makefile.com ! ignore any compiler and/or linker warning
$ copy make.exe 1st-make.exe
Use the 1st version to generate a 2nd version as a test.
$ mc sys$disk:[]1st-make clean ! ignore any file not found messages
$ mc sys$disk:[]1st-make
Verify your 2nd version by building Make again.
$ copy make.exe 2nd-make.exe
$ mc sys$disk:[]2nd-make clean
$ mc sys$disk:[]2nd-make
Running the tests:
------------------
Running the tests on OpenVMS requires the following software to be installed
as most of the tests are Unix oriented.
* Perl 5.18 or later.
https://sourceforge.net/projects/vmsperlkit/files/
* GNV 2.1.3 + Updates including a minimum of:
* Bash 4.3.30
* ld_tools 3.0.2
* coreutils 8.21
https://sourceforge.net/p/gnv/wiki/InstallingGNVPackages/
https://sourceforge.net/projects/gnv/files/
As the test scripts need to create some foreign commands that persist
after the test is run, it is recommend that either you use a subprocess or
a dedicated login to run the tests.
To get detailed information for running the tests:
$ set default [.tests]
$ @run_make_tests help
Running the script with no parameters will run all the tests.
After the the test script has been run once in a session, assuming
that you built make in sys$disk:[make], you can redefined the
"bin" logical name as follows:
$ define bin sys$disk:[make],gnv$gnu:[bin]
Then you can use Perl to run the scripts.
$ perl run_make_tests.pl
Acknowlegements:
----------------
See NEWS. for details of past changes.
These are the currently known contributers to this port.
Hartmut Becker
John Malmberg
Michael Gehre
John Eisenbraun
Klaus Kaempf
Mike Moretti
John W. Eaton

314
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.W32 Normal file
View File

@ -0,0 +1,314 @@
This version of GNU make has been tested on:
Microsoft Windows 2000/XP/2003/Vista/7/8/10
It has also been used on Windows 95/98/NT, and on OS/2.
It builds with the MinGW port of GCC (tested with GCC 3.4.2, 4.8.1,
and 4.9.3).
It also builds with MSVC 2.x, 4.x, 5.x, 6.x, 2003, and 14 (2015) as
well as with .NET 7.x and .NET 2003.
As of version 4.0, a build with Guile is supported (tested with Guile
2.0.3). To build with Guile, you will need, in addition to Guile
itself, its dependency libraries and the pkg-config program. The
latter is used to figure out which compilation and link switches and
libraries need to be mentioned on the compiler command lines to
correctly link with Guile. A Windows port of pkg-config can be found
on ezwinports site:
http://sourceforge.net/projects/ezwinports/
The libraries on which Guile depends can vary depending on your
version and build of Guile. At the very least, the Boehm's GC library
will be needed, and typically also GNU MP, libffi, libunistring, and
libtool's libltdl. Whoever built the port of Guile you have should
also provide you with these dependencies or a URL where to download
them. A precompiled 32-bit Windows build of Guile is available from
the ezwinports site mentioned above.
The Windows port of GNU make is maintained jointly by various people.
It was originally made by Rob Tulloh.
It is currently maintained by Eli Zaretskii.
Do this first, regardless of the build method you choose:
---------------------------------------------------------
1. Edit config.h.W32 to your liking (especially the few shell-related
defines near the end, or HAVE_CASE_INSENSITIVE_FS which corresponds
to './configure --enable-case-insensitive-file-system'). (We don't
recommend to define HAVE_CASE_INSENSITIVE_FS, but you may wish to
consider that if you have a lot of files whose names are in upper
case, while Makefile rules are written for lower-case versions.)
Using make_msvc_net2003.vcproj
------------------------------
2. Open make_msvc_net2003.vcproj in MSVS71 or MSVC71 or any compatible IDE,
then build this project as usual. There's also a solution file for
Studio 2003.
Building with (MinGW-)GCC using build_w32.bat
---------------------------------------------
2. Open a W32 command prompt for your installed (MinGW-)GCC, setup a
correct PATH and other environment variables for it, then execute ...
build_w32.bat gcc
This produces gnumake.exe in the GccRel directory.
If you want a version of GNU make built with debugging enabled,
add the --debug option.
The batch file will probe for Guile installation, and will build
gnumake.exe with Guile if it finds it. If you have Guile
installed, but want to build Make without Guile support, type
build_w32.bat --without-guile gcc
Building with (MSVC++-)cl using build_w32.bat or NMakefile
----------------------------------------------------------
2. Open a W32 command prompt for your installed (MSVC++-)cl, setup a
correct PATH and other environment variables for it (usually via
executing vcvars32.bat or vsvars32.bat from the cl-installation,
e.g. "%VS71COMNTOOLS%vsvars32.bat"; or using a corresponding start
menue entry from the cl-installation), then execute EITHER ...
build_w32.bat
This produces gnumake.exe in the WinRel directory.
If you want a version of GNU make built with debugging enabled,
add the --debug option.
... OR ...
nmake /f NMakefile
(this produces WinDebug/make.exe and WinRel/make.exe).
The batch file will probe for Guile installation, and will build
gnumake.exe with Guile if it finds it. If you have Guile
installed, but want to build Make without Guile support, type
build_w32.bat --without-guile
-------------------
-- Notes/Caveats --
-------------------
GNU make on Windows 32-bit platforms:
This version of make is ported natively to Windows32 platforms
(Windows NT 3.51, Windows NT 4.0, Windows 2000, Windows XP,
Windows 95, and Windows 98). It does not rely on any 3rd party
software or add-on packages for building. The only thing
needed is a Windows compiler. Two compilers supported
officially are the MinGW port of GNU GCC, and the various
versions of the Microsoft C compiler.
Do not confuse this port of GNU make with other Windows32 projects
which provide a GNU make binary. These are separate projects
and are not connected to this port effort.
GNU make and sh.exe:
This port prefers if you have a working sh.exe somewhere on
your system. If you don't have sh.exe, the port falls back to
MSDOS mode for launching programs (via a batch file). The
MSDOS mode style execution has not been tested that carefully
though (The author uses GNU bash as sh.exe).
There are very few true ports of Bourne shell for NT right now.
There is a version of GNU bash available from Cygnus "Cygwin"
porting effort (http://www.cygwin.com/).
Other possibilities are the MKS version of sh.exe, or building
your own with a package like NutCracker (DataFocus) or Portage
(Consensys). Also MinGW includes sh (http://mingw.org/).
GNU make and brain-dead shells (BATCH_MODE_ONLY_SHELL):
Some versions of Bourne shell do not behave well when invoked
as 'sh -c' from CreateProcess(). The main problem is they seem
to have a hard time handling quoted strings correctly. This can
be circumvented by writing commands to be executed to a batch
file and then executing the command by calling 'sh file'.
To work around this difficulty, this version of make supports
a batch mode. When BATCH_MODE_ONLY_SHELL is defined at compile
time, make forces all command lines to be executed via script
files instead of by command line. In this mode you must have a
working sh.exe in order to use parallel builds (-j).
A native Windows32 system with no Bourne shell will also run
in batch mode. All command lines will be put into batch files
and executed via $(COMSPEC) (%COMSPEC%). However, parallel
builds ARE supported with Windows shells (cmd.exe and
command.com). See the next section about some peculiarities
of parallel builds on Windows.
Support for parallel builds
Parallel builds (-jN) are supported in this port, with 1
limitation: The number of concurrent processes has a hard
limit of 64, due to the way this port implements waiting for
its subprocesses.
GNU make and Cygnus GNU Windows32 tools:
Good news! Make now has native support for Cygwin sh. To enable,
define the HAVE_CYGWIN_SHELL in config.h and rebuild make
from scratch. This version of make tested with B20.1 of Cygwin.
Do not define BATCH_MODE_ONLY_SHELL if you use HAVE_CYGWIN_SHELL.
GNU make and the MKS shell:
There is now semi-official support for the MKS shell. To turn this
support on, define HAVE_MKS_SHELL in the config.h.W32 before you
build make. Do not define BATCH_MODE_ONLY_SHELL if you turn
on HAVE_MKS_SHELL.
GNU make handling of drive letters in pathnames (PATH, vpath, VPATH):
There is a caveat that should be noted with respect to handling
single character pathnames on Windows systems. When colon is
used in PATH variables, make tries to be smart about knowing when
you are using colon as a separator versus colon as a drive
letter. Unfortunately, something as simple as the string 'x:/'
could be interpreted 2 ways: (x and /) or (x:/).
Make chooses to interpret a letter plus colon (e.g. x:/) as a
drive letter pathname. If it is necessary to use single
character directories in paths (VPATH, vpath, Path, PATH), the
user must do one of two things:
a. Use semicolon as the separator to disambiguate colon. For
example use 'x;/' if you want to say 'x' and '/' are
separate components.
b. Qualify the directory name so that there is more than
one character in the path(s) used. For example, none
of these settings are ambiguous:
./x:./y
/some/path/x:/some/path/y
x:/some/path/x:x:/some/path/y
Please note that you are free to mix colon and semi-colon in the
specification of paths. Make is able to figure out the intended
result and convert the paths internally to the format needed
when interacting with the operating system, providing the path
is not within quotes, e.g. "x:/test/test.c".
You are encouraged to use colon as the separator character.
This should ease the pain of deciding how to handle various path
problems which exist between platforms. If colon is used on
both Unix and Windows systems, then no ifdef'ing will be
necessary in the makefile source.
GNU make test suite:
I verified all functionality with a slightly modified version
of make-test-4.2.1 (modifications to get test suite to run
on Windows NT). All tests pass in an environment that includes
sh.exe. Tests were performed on both Windows NT and Windows 95.
Pathnames and white space:
Unlike Unix, Windows 95/NT systems encourage pathnames which
contain white space (e.g. C:\Program Files\). These sorts of
pathnames are valid on Unix too, but are never encouraged.
There is at least one place in make (VPATH/vpath handling) where
paths containing white space will simply not work. There may be
others too. I chose to not try and port make in such a way so
that these sorts of paths could be handled. I offer these
suggestions as workarounds:
1. Use 8.3 notation. i.e. "x:/long~1/", which is actually
"x:\longpathtest". Type "dir /x" to view these filenames
within the cmd.exe shell.
2. Rename the directory so it does not contain white space.
If you are unhappy with this choice, this is free software
and you are free to take a crack at making this work. The code
in w32/pathstuff.c and vpath.c would be the places to start.
Pathnames and Case insensitivity:
Unlike Unix, Windows 95/NT systems are case insensitive but case
preserving. For example if you tell the file system to create a
file named "Target", it will preserve the case. Subsequent access to
the file with other case permutations will succeed (i.e. opening a
file named "target" or "TARGET" will open the file "Target").
By default, GNU make retains its case sensitivity when comparing
target names and existing files or directories. It can be
configured, however, into a case preserving and case insensitive
mode by adding a define for HAVE_CASE_INSENSITIVE_FS to
config.h.W32.
For example, the following makefile will create a file named
Target in the directory subdir which will subsequently be used
to satisfy the dependency of SUBDIR/DepTarget on SubDir/TARGET.
Without HAVE_CASE_INSENSITIVE_FS configured, the dependency link
will not be made:
subdir/Target:
touch $@
SUBDIR/DepTarget: SubDir/TARGET
cp $^ $@
Reliance on this behavior also eliminates the ability of GNU make
to use case in comparison of matching rules. For example, it is
not possible to set up a C++ rule using %.C that is different
than a C rule using %.c. GNU make will consider these to be the
same rule and will issue a warning.
SAMBA/NTFS/VFAT:
I have not had any success building the debug version of this
package using SAMBA as my file server. The reason seems to be
related to the way VC++ 4.0 changes the case name of the pdb
filename it is passed on the command line. It seems to change
the name always to to lower case. I contend that the VC++
compiler should not change the casename of files that are passed
as arguments on the command line. I don't think this was a
problem in MSVC 2.x, but I know it is a problem in MSVC 4.x.
The package builds fine on VFAT and NTFS filesystems.
Most all of the development I have done to date has been using
NTFS and long file names. I have not done any considerable work
under VFAT. VFAT users may wish to be aware that this port of
make does respect case sensitivity.
FAT:
Version 3.76 added support for FAT filesystems. Make works
around some difficulties with stat'ing of files and caching of
filenames and directories internally.
Bug reports:
Please submit bugs via the normal bug reporting mechanism which
is described in the GNU make manual and the base README.
-------------------------------------------------------------------------------
Copyright (C) 1996-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

112
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/licenses/make-4.2.1/README.customs Normal file
View File

@ -0,0 +1,112 @@
-*-indented-text-*-
GNU make can utilize the Customs library, distributed with Pmake, to
provide builds distributed across multiple hosts.
In order to utilize this capability, you must first download and build
the Customs library. It is contained in the Pmake distribution, which
can be obtained at:
ftp://ftp.icsi.berkeley.edu/pub/ai/stolcke/software/
This integration was tested (superficially) with Pmake 2.1.33.
BUILDING CUSTOMS
----------------
First, build pmake and Customs. You need to build pmake first, because
Customs require pmake to build. Unfortunately, this is not trivial;
please see the pmake and Customs documentation for details. The best
place to look for instructions is in the pmake-2.1.33/INSTALL file.
Note that the 2.1.33 Pmake distribution comes with a set of patches to
GNU make, distributed in the pmake-2.1.33/etc/gnumake/ directory. These
patches are based on GNU make 3.75 (there are patches for earlier
versions of GNU make, also). The parts of this patchfile which relate
directly to Customs support have already been incorporated into this
version of GNU make, so you should _NOT_ apply the patch file.
However, there are a few non-Customs specific (as far as I could tell)
changes here which are not incorporated (for example, the modification
to try expanding -lfoo to libfoo.so). If you rely on these changes
you'll need to re-apply them by hand.
Install the Customs library and header files according to the
documentation. You should also install the man pages (contrary to
comments in the documentation, they weren't installed automatically for
me; I had to cd to the 'pmake-2.1.33/doc' directory and run 'pmake
install' there directly).
BUILDING GNU MAKE
-----------------
Once you've installed Customs, you can build GNU make to use it. When
configuring GNU make, merely use the '--with-customs=DIR' option.
Provide the directory containing the 'lib' and 'include/customs'
subdirectories as DIR. For example, if you installed the customs
library in /usr/local/lib and the headers in /usr/local/include/customs,
then you'd pass '--with-customs=/usr/local' as an option to configure.
Run make (or use build.sh) normally to build GNU make as described in
the INSTALL file.
See the documentation for Customs for information on starting and
configuring Customs.
INVOKING CUSTOMS-IZED GNU MAKE
-----------------------------
One thing you should be aware of is that the default build environment
for Customs requires root permissions. Practically, this means that GNU
make must be installed setuid root to use Customs.
If you don't want to do this, you can build Customs such that root
permissions are not necessary. Andreas Stolcke <stolcke@speech.sri.com>
writes:
> pmake, gnumake or any other customs client program is not required to
> be suid root if customs was compiled WITHOUT the USE_RESERVED_PORTS
> option in customs/config.h. Make sure the "customs" service in
> /etc/services is defined accordingly (port 8231 instead of 1001).
> Not using USE_RESERVED_PORTS means that a user with programming
> skills could impersonate another user by writing a fake customs
> client that pretends to be someone other than himself. See the
> discussion in etc/SECURITY.
PROBLEMS
--------
SunOS 4.1.x:
The customs/sprite.h header file #includes the <malloc.h> header
files; this conflicts with GNU make's configuration so you'll get a
compile error if you use GCC (or any other ANSI-capable C compiler).
I commented out the #include in sprite.h:107:
#if defined(sun) || defined(ultrix) || defined(hpux) || defined(sgi)
/* #include <malloc.h> */
#else
YMMV.
-------------------------------------------------------------------------------
Copyright (C) 1998-2016 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.

0
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/patches/.gitkeep Normal file
View File

1
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/VERSION Normal file
View File

@ -0,0 +1 @@
2.12

130
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/build.sh Normal file
View File

@ -0,0 +1,130 @@
#!/usr/bin/env bash
# -----------------------------------------------------------------------------
# This file is part of the GNU MCU Eclipse distribution.
# (https://gnu-mcu-eclipse.github.io)
# Copyright (c) 2019 Liviu Ionescu.
#
# Permission to use, copy, modify, and/or distribute this software
# for any purpose is hereby granted, under the terms of the MIT license.
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Safety settings (see https://gist.github.com/ilg-ul/383869cbb01f61a51c4d).
if [[ ! -z ${DEBUG} ]]
then
set ${DEBUG} # Activate the expand mode if DEBUG is anything but empty.
else
DEBUG=""
fi
set -o errexit # Exit if command failed.
set -o pipefail # Exit if pipe failed.
set -o nounset # Exit if variable not set.
# Remove the initial space and instead use '\n'.
IFS=$'\n\t'
# -----------------------------------------------------------------------------
# Identify the script location, to reach, for example, the helper scripts.
build_script_path="$0"
if [[ "${build_script_path}" != /* ]]
then
# Make relative path absolute.
build_script_path="$(pwd)/$0"
fi
script_folder_path="$(dirname "${build_script_path}")"
script_folder_name="$(basename "${script_folder_path}")"
# =============================================================================
# Script to cross build the 32/64-bit Windows version of Build Tools
# with MinGW-w64 on GNU/Linux.
#
# Developed on macOS 10.13 High Sierra, but intended to run on
# CentOS 6 XBB.
# -----------------------------------------------------------------------------
echo
echo "GNU MCU Eclipse Windows Build Tools distribution build script."
host_functions_script_path="${script_folder_path}/helper/host-functions-source.sh"
source "${host_functions_script_path}"
# -----------------------------------------------------------------------------
# Array where the remaining args will be stored.
declare -a rest
help_message=" bash $0 [--win32] [--win64] [--all] [clean|cleanall|preload-images] [--env-file file] [--date YYYYmmdd-HHMM] [--disable-strip] [--without-pdf] [--with-html] [--develop] [--debug] [--jobs N] [--help]"
host_options_windows "${help_message}" $@
echo
echo "Host helper functions source script: \"${host_functions_script_path}\"."
host_detect
# docker_linux64_image="ilegeul/centos:6-xbb-v2.1"
# docker_linux32_image="ilegeul/centos32:6-xbb-v2.1"
host_common
CONTAINER_RUN_AS_ROOT="y"
# -----------------------------------------------------------------------------
if [ -n "${DO_BUILD_WIN32}${DO_BUILD_WIN64}" ]
then
host_prepare_docker
# ----- Build the Windows 64-bit distribution. -----------------------------
if [ "${DO_BUILD_WIN64}" == "y" ]
then
host_build_target "Creating the Windows 64-bit distribution..." \
--script "${CONTAINER_WORK_FOLDER_PATH}/${CONTAINER_BUILD_SCRIPT_REL_PATH}" \
--env-file "${ENV_FILE}" \
--target-platform "win32" \
--target-arch "x64" \
--target-bits 64 \
--docker-image "${docker_linux64_image}" \
-- \
${rest[@]-}
fi
# ----- Build the Windows 32-bit distribution. -----------------------------
# Since the actual container is a 32-bit, use the debian32 binaries.
if [ "${DO_BUILD_WIN32}" == "y" ]
then
host_build_target "Creating the Windows 32-bit distribution..." \
--script "${CONTAINER_WORK_FOLDER_PATH}/${CONTAINER_BUILD_SCRIPT_REL_PATH}" \
--env-file "${ENV_FILE}" \
--target-platform "win32" \
--target-arch "x32" \
--target-bits 32 \
--docker-image "${docker_linux32_image}" \
-- \
${rest[@]-}
fi
fi
host_show_sha
# -----------------------------------------------------------------------------
host_stop_timer
host_notify_completed
echo
echo "Use --date ${DISTRIBUTION_FILE_DATE} if needed to resume a build."
# Completed successfully.
exit 0
# -----------------------------------------------------------------------------

303
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/container-apps-functions-source.sh Normal file
View File

@ -0,0 +1,303 @@
# -----------------------------------------------------------------------------
# This file is part of the GNU MCU Eclipse distribution.
# (https://gnu-mcu-eclipse.github.io)
# Copyright (c) 2019 Liviu Ionescu.
#
# Permission to use, copy, modify, and/or distribute this software
# for any purpose is hereby granted, under the terms of the MIT license.
# -----------------------------------------------------------------------------
# Helper script used in the second edition of the GNU MCU Eclipse build
# scripts. As the name implies, it should contain only functions and
# should be included with 'source' by the container build scripts.
# -----------------------------------------------------------------------------
# The surprise of this build was that building the cross guile requires
# a native guile; thus the need to build everything twice, first the
# native build, than the cross build.
# -----------------------------------------------------------------------------
function do_make()
{
# The make executable is built using the source package from
# the open source MSYS2 project.
# https://sourceforge.net/projects/msys2/
MSYS2_MAKE_PACK_URL_BASE="http://sourceforge.net/projects/msys2/files"
# http://sourceforge.net/projects/msys2/files/REPOS/MSYS2/Sources/
# http://sourceforge.net/projects/msys2/files/REPOS/MSYS2/Sources/make-4.1-4.src.tar.gz/download
# Warning! 4.2 requires gettext-0.19.4. it does not build on Debian 8.
# 2016-06-15
MAKE_VERSION="4.2.1"
MSYS2_MAKE_VERSION_RELEASE="${MAKE_VERSION}-1"
MSYS2_MAKE_FOLDER_NAME="make-${MSYS2_MAKE_VERSION_RELEASE}"
local msys2_make_archive="${MSYS2_MAKE_FOLDER_NAME}.src.tar.gz"
local msys2_make_url="${MSYS2_MAKE_PACK_URL_BASE}/REPOS/MSYS2/Sources/${msys2_make_archive}"
MAKE_FOLDER_NAME="make-${MAKE_VERSION}"
local make_archive="${MAKE_FOLDER_NAME}.tar.bz2"
local make_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-make-${MSYS2_MAKE_VERSION_RELEASE}-installed"
if [ ! -f "${make_stamp_file_path}" -o ! -d "${BUILD_FOLDER_PATH}/${MAKE_FOLDER_NAME}" ]
then
if [ ! -f "${SOURCES_FOLDER_PATH}/msys2/make/${make_archive}" ]
then
(
mkdir -p "${SOURCES_FOLDER_PATH}/msys2"
cd "${SOURCES_FOLDER_PATH}/msys2"
download_and_extract "${msys2_make_url}" "${msys2_make_archive}" "make"
)
fi
if [ ! -d "${SOURCES_FOLDER_PATH}/${MAKE_FOLDER_NAME}" ]
then
(
cd "${SOURCES_FOLDER_PATH}"
echo
echo "Unpacking ${make_archive}..."
tar -xvf "${SOURCES_FOLDER_PATH}/msys2/make/${make_archive}"
cd "${SOURCES_FOLDER_PATH}/${MAKE_FOLDER_NAME}"
xbb_activate
echo "Running make autoreconf..."
autoreconf -fi
)
fi
(
mkdir -p "${BUILD_FOLDER_PATH}/${MAKE_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${MAKE_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
(
echo
echo "Running make configure..."
# cd "${make_build_folder}"
bash "${SOURCES_FOLDER_PATH}/${MAKE_FOLDER_NAME}/configure" --help
export CFLAGS="${XBB_CFLAGS}"
export LDFLAGS="${XBB_LDFLAGS_APP} -static"
echo
bash "${SOURCES_FOLDER_PATH}/${MAKE_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}/make-${MAKE_VERSION}" \
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--without-guile \
--without-libintl-prefix \
--without-libiconv-prefix \
ac_cv_dos_paths=yes \
\
cp "config.log" "${LOGS_FOLDER_PATH}/config-make-log.txt"
) 2>&1 | tee "${LOGS_FOLDER_PATH}/configure-make-output.txt"
fi
(
echo
echo "Running make make..."
# Build.
make -j ${JOBS}
make install-strip
) 2>&1 | tee "${LOGS_FOLDER_PATH}/make-make-output.txt"
)
touch "${make_stamp_file_path}"
else
echo "make already installed."
fi
}
function do_busybox()
{
# https://frippery.org/busybox/
# https://github.com/rmyorston/busybox-w32
# BUSYBOX_COMMIT=master
# BUSYBOX_COMMIT="9fe16f6102d8ab907c056c484988057904092c06"
# BUSYBOX_COMMIT="977d65c1bbc57f5cdd0c8bfd67c8b5bb1cd390dd"
# BUSYBOX_COMMIT="9fa1e4990e655a85025c9d270a1606983e375e47"
# BUSYBOX_COMMIT="c2002eae394c230d6b89073c9ff71bc86a7875e8"
# Dec 9, 2017
# BUSYBOX_COMMIT="096aee2bb468d1ab044de36e176ed1f6c7e3674d"
# Apr 13, 2018
# BUSYBOX_COMMIT="6f7d1af269eed4b42daeb9c6dfd2ba62f9cd47e4"
# Apr 06, 2019
BUSYBOX_COMMIT="65ae5b24cc08f898e81b36421b616fc7fc25d2b1"
BUSYBOX_ARCHIVE="${BUSYBOX_COMMIT}.zip"
BUSYBOX_URL="https://github.com/rmyorston/busybox-w32/archive/${BUSYBOX_ARCHIVE}"
BUSYBOX_SRC_FOLDER="busybox-w32-${BUSYBOX_COMMIT}"
# Does not use configure and builds in the source folder.
cd "${BUILD_FOLDER_PATH}"
download_and_extract "${BUSYBOX_URL}" "${BUSYBOX_ARCHIVE}" "${BUSYBOX_SRC_FOLDER}"
local busybox_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-busybox-${BUSYBOX_COMMIT}-installed"
if [ ! -f "${busybox_stamp_file_path}" ]
then
(
cd "${BUILD_FOLDER_PATH}"
if [ ! -f "${BUILD_FOLDER_PATH}/${BUSYBOX_SRC_FOLDER}/.config" ]
then
(
echo
echo "Running BusyBox configure..."
xbb_activate
cd "${BUILD_FOLDER_PATH}/${BUSYBOX_SRC_FOLDER}"
if [ ${TARGET_BITS} == "32" ]
then
# On 32-bit containers running on 64-bit systems, stat() fails with
# 'Value too large for defined data type'.
# The solution is to add _FILE_OFFSET_BITS=64.
export HOST_EXTRACFLAGS="-D_FILE_OFFSET_BITS=64"
make mingw32_defconfig \
HOSTCC="gcc-7" \
HOSTCXX="g++-7"
elif [ ${TARGET_BITS} == "64" ]
then
make mingw64_defconfig \
HOSTCC="gcc-7" \
HOSTCXX="g++-7"
fi
) 2>&1 | tee "${LOGS_FOLDER_PATH}/configure-busybox-output.txt"
fi
if [ ! -f "${BUILD_FOLDER_PATH}/${BUSYBOX_SRC_FOLDER}/busybox.exe" ]
then
(
echo
echo "Running BusyBox make..."
xbb_activate
export CFLAGS="${XBB_CFLAGS} -Wno-format-extra-args -Wno-format -Wno-overflow -Wno-unused-variable -Wno-implicit-function-declaration -Wno-unused-parameter -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-strict-prototypes -Wno-old-style-definition -Wno-implicit-function-declaration -Wno-incompatible-pointer-types -Wno-discarded-qualifiers -Wno-strict-prototypes -Wno-old-style-definition -Wno-unused-function -Wno-int-to-pointer-cast"
export LDFLAGS="${XBB_LDFLAGS_APP} -static"
if [ ${TARGET_BITS} == "32" ]
then
# Required since some of the host tools are built here.
export HOST_EXTRACFLAGS="-D_FILE_OFFSET_BITS=64"
fi
cd "${BUILD_FOLDER_PATH}/${BUSYBOX_SRC_FOLDER}"
make \
HOSTCC="gcc-7" \
HOSTCXX="g++-7"
mkdir -p "${INSTALL_FOLDER_PATH}/busybox-w32/bin"
cp busybox.exe "${INSTALL_FOLDER_PATH}/busybox-w32/bin"
) 2>&1 | tee "${LOGS_FOLDER_PATH}/make-busybox-output.txt"
fi
)
touch "${busybox_stamp_file_path}"
else
echo "BusyBox already installed."
fi
}
function copy_binaries()
{
mkdir -p "${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin"
(
xbb_activate
echo
echo "Copy make to install bin..."
cp -v "${INSTALL_FOLDER_PATH}/make-${MAKE_VERSION}/bin/make.exe" \
"${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin"
${CROSS_COMPILE_PREFIX}-strip \
"${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin/make.exe"
echo
echo "Copy BusyBox to install bin..."
cp -v "${INSTALL_FOLDER_PATH}/busybox-w32/bin/busybox.exe" \
"${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin"
${CROSS_COMPILE_PREFIX}-strip \
"${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin/busybox.exe"
(
cd "${INSTALL_FOLDER_PATH}/${APP_LC_NAME}/bin"
cp -v "busybox.exe" "sh.exe"
cp -v "busybox.exe" "rm.exe"
cp -v "busybox.exe" "echo.exe"
cp -v "busybox.exe" "mkdir.exe"
)
)
}
function check_binaries()
{
echo
echo "Checking binaries for unwanted DLLs..."
local binaries=$(find "${INSTALL_FOLDER_PATH}/${APP_LC_NAME}"/bin -name \*.exe)
for bin in ${binaries}
do
check_binary "${bin}"
done
}
function copy_distro_files()
{
(
xbb_activate
rm -rf "${APP_PREFIX}/${DISTRO_LC_NAME}"
mkdir -p "${APP_PREFIX}/${DISTRO_LC_NAME}"
echo
echo "Copying license files..."
copy_license \
"${SOURCES_FOLDER_PATH}/${MAKE_FOLDER_NAME}" \
"${MAKE_FOLDER_NAME}"
copy_license \
"${BUILD_FOLDER_PATH}/${BUSYBOX_SRC_FOLDER}" \
"busybox-w32"
copy_build_files
echo
echo "Copying distro files..."
cd "${WORK_FOLDER_PATH}/build.git"
install -v -c -m 644 "README-out.md" "${APP_PREFIX}/README.md"
)
}

199
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/container-build.sh Normal file
View File

@ -0,0 +1,199 @@
#!/usr/bin/env bash
# -----------------------------------------------------------------------------
# This file is part of the GNU MCU Eclipse distribution.
# (https://gnu-mcu-eclipse.github.io)
# Copyright (c) 2019 Liviu Ionescu.
#
# Permission to use, copy, modify, and/or distribute this software
# for any purpose is hereby granted, under the terms of the MIT license.
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Safety settings (see https://gist.github.com/ilg-ul/383869cbb01f61a51c4d).
if [[ ! -z ${DEBUG} ]]
then
set ${DEBUG} # Activate the expand mode if DEBUG is anything but empty.
else
DEBUG=""
fi
set -o errexit # Exit if command failed.
set -o pipefail # Exit if pipe failed.
set -o nounset # Exit if variable not set.
# Remove the initial space and instead use '\n'.
IFS=$'\n\t'
# -----------------------------------------------------------------------------
# Identify the script location, to reach, for example, the helper scripts.
build_script_path="$0"
if [[ "${build_script_path}" != /* ]]
then
# Make relative path absolute.
build_script_path="$(pwd)/$0"
fi
script_folder_path="$(dirname "${build_script_path}")"
script_folder_name="$(basename "${script_folder_path}")"
# =============================================================================
# Inner script to run inside Docker containers to build the
# GNU MCU Eclipse Windows Build Tools distribution packages.
defines_script_path="${script_folder_path}/defs-source.sh"
echo "Definitions source script: \"${defines_script_path}\"."
source "${defines_script_path}"
# This file is generated by the host build script.
host_defines_script_path="${script_folder_path}/host-defs-source.sh"
echo "Host definitions source script: \"${host_defines_script_path}\"."
source "${host_defines_script_path}"
common_helper_functions_script_path="${script_folder_path}/helper/common-functions-source.sh"
echo "Common helper functions source script: \"${common_helper_functions_script_path}\"."
source "${common_helper_functions_script_path}"
container_functions_script_path="${script_folder_path}/helper/container-functions-source.sh"
echo "Container helper functions source script: \"${container_functions_script_path}\"."
source "${container_functions_script_path}"
container_libs_functions_script_path="${script_folder_path}/${CONTAINER_LIBS_FUNCTIONS_SCRIPT_NAME}"
echo "Container lib functions source script: \"${container_libs_functions_script_path}\"."
source "${container_libs_functions_script_path}"
container_app_functions_script_path="${script_folder_path}/${CONTAINER_APPS_FUNCTIONS_SCRIPT_NAME}"
echo "Container app functions source script: \"${container_app_functions_script_path}\"."
source "${container_app_functions_script_path}"
# -----------------------------------------------------------------------------
if [ ! -z "#{DEBUG}" ]
then
echo $@
fi
WITH_STRIP="y"
WITHOUT_MULTILIB=""
WITH_PDF="y"
WITH_HTML="n"
IS_DEVELOP=""
IS_DEBUG=""
LINUX_INSTALL_PATH=""
JOBS=""
while [ $# -gt 0 ]
do
case "$1" in
--disable-strip)
WITH_STRIP="n"
shift
;;
--without-pdf)
WITH_PDF="n"
shift
;;
--with-pdf)
WITH_PDF="y"
shift
;;
--without-html)
WITH_HTML="n"
shift
;;
--with-html)
WITH_HTML="y"
shift
;;
--jobs)
JOBS=$2
shift 2
;;
--develop)
IS_DEVELOP="y"
shift
;;
--debug)
IS_DEBUG="y"
WITH_STRIP="n"
shift
;;
*)
echo "Unknown action/option $1"
exit 1
;;
esac
done
# -----------------------------------------------------------------------------
start_timer
detect_container
prepare_xbb_env
prepare_xbb_extras
# -----------------------------------------------------------------------------
echo
echo "Here we go..."
echo
# Test to build guile
if false
then
do_gmp
do_libtool
do_libunistring
do_libffi
do_bdwgc
do_libiconv
do_guile
fi
do_make
do_busybox
# -----------------------------------------------------------------------------
copy_binaries
# -----------------------------------------------------------------------------
check_binaries
copy_distro_files
create_archive
# Change ownership to non-root Linux user.
fix_ownership
# -----------------------------------------------------------------------------
stop_timer
exit 0
# -----------------------------------------------------------------------------

942
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/container-libs-functions-source.sh Normal file
View File

@ -0,0 +1,942 @@
# -----------------------------------------------------------------------------
# This file is part of the GNU MCU Eclipse distribution.
# (https://gnu-mcu-eclipse.github.io)
# Copyright (c) 2019 Liviu Ionescu.
#
# Permission to use, copy, modify, and/or distribute this software
# for any purpose is hereby granted, under the terms of the MIT license.
# -----------------------------------------------------------------------------
# Helper script used in the second edition of the GNU MCU Eclipse build
# scripts. As the name implies, it should contain only functions and
# should be included with 'source' by the container build scripts.
# -----------------------------------------------------------------------------
# The surprise of this build was that building the cross guile requires
# a native guile; thus the need to build everything twice, first the
# native build, than the cross build.
# -----------------------------------------------------------------------------
function do_gmp()
{
# https://gmplib.org
# https://gmplib.org/download/gmp/
# https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=gmp-hg
# 01-Nov-2015
# GMP_VERSION="6.1.0"
# 16-Dec-2016
# GMP_VERSION="6.1.2"
GMP_VERSION="6.1.0"
GMP_FOLDER_NAME="gmp-${GMP_VERSION}"
local gmp_archive="${GMP_FOLDER_NAME}.tar.xz"
# local gmp_url="https://gmplib.org/download/gmp/${gmp_archive}"
local gmp_url="https://github.com/gnu-mcu-eclipse/files/raw/master/libs/${gmp_archive}"
local gmp_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-gmp-installed"
if [ ! -f "${gmp_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${gmp_url}" "${gmp_archive}" "${GMP_FOLDER_NAME}"
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${GMP_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${GMP_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native gmp configure..."
# ABI is mandatory, otherwise configure fails on 32-bits.
# (see https://gmplib.org/manual/ABI-and-ISA.html)
bash "${WORK_FOLDER_PATH}/${GMP_FOLDER_NAME}/configure" --help
export CFLAGS="-Wno-unused-value -Wno-empty-translation-unit -Wno-tautological-compare -Wno-overflow"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
export ABI="${TARGET_BITS}"
bash "${WORK_FOLDER_PATH}/${GMP_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
--enable-cxx \
| tee "${INSTALL_FOLDER_PATH}/configure-native-gmp-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-gmp-log.txt
fi
echo
echo "Running native gmp make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-gmp-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${GMP_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${GMP_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running gmp configure..."
# ABI is mandatory, otherwise configure fails on 32-bits.
# (see https://gmplib.org/manual/ABI-and-ISA.html)
bash "${WORK_FOLDER_PATH}/${GMP_FOLDER_NAME}/configure" --help
export CFLAGS="-Wno-unused-value -Wno-empty-translation-unit -Wno-tautological-compare -Wno-overflow"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS}"
export ABI="${TARGET_BITS}"
bash "${WORK_FOLDER_PATH}/${GMP_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
--enable-cxx \
| tee "${INSTALL_FOLDER_PATH}/configure-gmp-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-gmp-log.txt
fi
echo
echo "Running gmp make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-gmp-output.txt"
)
touch "${gmp_stamp_file_path}"
else
echo "Library gmp already installed."
fi
}
function do_libtool()
{
# https://www.gnu.org/software/libtool/
# http://gnu.mirrors.linux.ro/libtool/
# https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=libtool-git
# 2015-02-16
LIBTOOL_VERSION="2.4.6"
LIBTOOL_FOLDER_NAME="libtool-${LIBTOOL_VERSION}"
local libtool_archive="${LIBTOOL_FOLDER_NAME}.tar.gz"
# local libtool_url="http://www.mr511.de/software/${libtool_archive}"
local libtool_url="http://mirrors.nav.ro/gnu/libtool/${libtool_archive}"
local libtool_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-libtool-installed"
if [ ! -f "${libtool_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${libtool_url}" "${libtool_archive}" "${LIBTOOL_FOLDER_NAME}"
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${LIBTOOL_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${LIBTOOL_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native libtool configure..."
bash "${WORK_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
bash "${WORK_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
--disable-nls \
--disable-rpath \
| tee "${INSTALL_FOLDER_PATH}/configure-native-libtool-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-libtool-log.txt
fi
echo
echo "Running native libtool make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-native-libtool-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running libtool configure..."
bash "${WORK_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS}"
bash "${WORK_FOLDER_PATH}/${LIBTOOL_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
--disable-nls \
--disable-rpath \
| tee "${INSTALL_FOLDER_PATH}/configure-libtool-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-libtool-log.txt
fi
echo
echo "Running libtool make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-libtool-output.txt"
)
touch "${libtool_stamp_file_path}"
else
echo "Library libtool already installed."
fi
}
function do_libunistring()
{
# https://www.gnu.org/software/libunistring/
# https://ftp.gnu.org/gnu/libunistring/
# 2018-02-28
LIBUNISTRING_VERSION="0.9.9"
LIBUNISTRING_FOLDER_NAME="libunistring-${LIBUNISTRING_VERSION}"
local libunistring_archive="${LIBUNISTRING_FOLDER_NAME}.tar.xz"
local libunistring_url="http://ftp.gnu.org/gnu/libunistring/${libunistring_archive}"
local libunistring_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-libunistring-installed"
if [ ! -f "${libunistring_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${libunistring_url}" "${libunistring_archive}" "${LIBUNISTRING_FOLDER_NAME}"
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${LIBUNISTRING_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${LIBUNISTRING_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native libunistring configure..."
bash "${WORK_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS} -Wno-pointer-to-int-cast"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
bash "${WORK_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
| tee "${INSTALL_FOLDER_PATH}/configure-native-libunistring-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-libunistring-log.txt
fi
echo
echo "Running native libunistring make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-native-libunistring-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running libunistring configure..."
bash "${WORK_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS} -Wno-pointer-to-int-cast"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS_LIB}"
bash "${WORK_FOLDER_PATH}/${LIBUNISTRING_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
| tee "${INSTALL_FOLDER_PATH}/configure-libunistring-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-libunistring-log.txt
fi
echo
echo "Running libunistring make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-libunistring-output.txt"
)
touch "${libunistring_stamp_file_path}"
else
echo "Library libunistring already installed."
fi
}
function do_libffi()
{
# https://sourceware.org/libffi/
# https://sourceware.org/pub/libffi/
# https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=libffi-git
LIBFFI_VERSION="3.2.1"
LIBFFI_FOLDER_NAME="libffi-${LIBFFI_VERSION}"
local libffi_archive="${LIBFFI_FOLDER_NAME}.tar.gz"
# local libffi_url="http://isl.gforge.inria.fr/${libffi_archive}"
local libffi_url="https://sourceware.org/pub/libffi/${libffi_archive}"
local libffi_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-libffi-installed"
if [ ! -f "${libffi_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${libffi_url}" "${libffi_archive}" "${LIBFFI_FOLDER_NAME}"
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${LIBFFI_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${LIBFFI_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native libffi configure..."
bash "${WORK_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
bash "${WORK_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
--disable-nls \
| tee "${INSTALL_FOLDER_PATH}"/configure-native-libffi-output.txt
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-libffi-log.txt
fi
echo
echo "Running native libffi make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-native-libffi-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running libffi configure..."
bash "${WORK_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS_LIB}"
bash "${WORK_FOLDER_PATH}/${LIBFFI_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
| tee "${INSTALL_FOLDER_PATH}"/configure-libffi-output.txt
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-libffi-log.txt
fi
echo
echo "Running libffi make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-libffi-output.txt"
)
touch "${libffi_stamp_file_path}"
else
echo "Library libffi already installed."
fi
}
function do_bdwgc()
{
# http://www.hboehm.info/gc/
# http://www.hboehm.info/gc/gc_source/
BDWGC_VERSION="7.6.4"
BDWGC_FOLDER_NAME="gc-${BDWGC_VERSION}"
local bdwgc_archive="${BDWGC_FOLDER_NAME}.tar.gz"
local bdwgc_url="http://www.hboehm.info/gc/gc_source/${bdwgc_archive}"
LIBATOMIC_VERSION="7.6.2"
LIBATOMIC_FOLDER_NAME="libatomic_ops-${LIBATOMIC_VERSION}"
local libatomic_archive="${LIBATOMIC_FOLDER_NAME}.tar.gz"
local libatomic_url="http://www.hboehm.info/gc/gc_source/${libatomic_archive}"
local bdwgc_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-bdwgc-installed"
if [ ! -f "${bdwgc_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${bdwgc_url}" "${bdwgc_archive}" "${BDWGC_FOLDER_NAME}"
download_and_extract "${libatomic_url}" "${libatomic_archive}" "${LIBATOMIC_FOLDER_NAME}"
cd "${WORK_FOLDER_PATH}/${BDWGC_FOLDER_NAME}"
if [ ! -d libatomic_ops ]
then
ln -s "${WORK_FOLDER_PATH}/${LIBATOMIC_FOLDER_NAME}" libatomic_ops
fi
(
xbb_activate
autoreconf -vif
automake --add-missing
)
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${BDWGC_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${BDWGC_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native bdwgc configure..."
bash "${WORK_FOLDER_PATH}/${BDWGC_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
bash "${WORK_FOLDER_PATH}/${BDWGC_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
--disable-nls \
| tee "${INSTALL_FOLDER_PATH}/configure-native-bdwgc-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-bdwgc-log.txt
fi
echo
echo "Running native bdwgc make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-native-bdwgc-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${BDWGC_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${BDWGC_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running bdwgc configure..."
bash "${WORK_FOLDER_PATH}/${BDWGC_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS}"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS_LIB}"
bash "${WORK_FOLDER_PATH}/${BDWGC_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
--disable-nls \
| tee "${INSTALL_FOLDER_PATH}/configure-bdwgc-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-bdwgc-log.txt
fi
echo
echo "Running bdwgc make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-bdwgc-output.txt"
)
touch "${bdwgc_stamp_file_path}"
else
echo "Library bdwgc already installed."
fi
}
function do_libiconv()
{
# https://www.gnu.org/software/libiconv/
# https://ftp.gnu.org/pub/gnu/libiconv/
# https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=libiconv
# 2011-08-07
# LIBICONV_VERSION="1.14"
# 2017-02-02
# LIBICONV_VERSION="1.15"
LIBICONV_VERSION="1.14"
LIBICONV_FOLDER_NAME="libiconv-${LIBICONV_VERSION}"
local libiconv_archive="${LIBICONV_FOLDER_NAME}.tar.gz"
local libiconv_url="https://ftp.gnu.org/pub/gnu/libiconv/${libiconv_archive}"
local libiconv_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-libiconv-installed"
if [ ! -f "${libiconv_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${libiconv_url}" "${libiconv_archive}" "${LIBICONV_FOLDER_NAME}"
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${LIBICONV_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${LIBICONV_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native libiconv configure..."
bash "${WORK_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}/configure" --help
# -fgnu89-inline fixes "undefined reference to `aliases2_lookup'"
# https://savannah.gnu.org/bugs/?47953
export CFLAGS="${EXTRA_CFLAGS} -fgnu89-inline -Wno-tautological-compare -Wno-parentheses-equality -Wno-static-in-inline -Wno-pointer-to-int-cast"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
bash "${WORK_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
--disable-nls \
| tee "${INSTALL_FOLDER_PATH}/configure-native-libiconv-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-libiconv-log.txt
fi
echo
echo "Running native libiconv make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-native-libiconv-output.txt"
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running libiconv configure..."
bash "${WORK_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}/configure" --help
# -fgnu89-inline fixes "undefined reference to `aliases2_lookup'"
# https://savannah.gnu.org/bugs/?47953
export CFLAGS="${EXTRA_CFLAGS} -fgnu89-inline -Wno-tautological-compare -Wno-parentheses-equality -Wno-static-in-inline -Wno-pointer-to-int-cast"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS}"
bash "${WORK_FOLDER_PATH}/${LIBICONV_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
--disable-nls \
| tee "${INSTALL_FOLDER_PATH}/configure-libiconv-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-libiconv-log.txt
fi
echo
echo "Running libiconv make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-libiconv-output.txt"
)
touch "${libiconv_stamp_file_path}"
else
echo "Library libiconv already installed."
fi
}
function do_guile()
{
# https://www.gnu.org/software/guile/
# https://ftp.gnu.org/gnu/guile/
# https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=guile-git
# 2017-02-13
# make searches for 2.0 or 1.8
GUILE_VERSION="2.0.14"
# 2017-12-01
# GUILE_VERSION="2.2.3"
GUILE_FOLDER_NAME="guile-${GUILE_VERSION}"
# local guile_archive="${GUILE_FOLDER_NAME}.tar.xz"
# local guile_url="https://ftp.gnu.org/gnu/guile/${guile_archive}"
MSYS2_GUILE_PACK_URL_BASE="http://sourceforge.net/projects/msys2/files"
# http://sourceforge.net/projects/msys2/files/REPOS/MSYS2/Sources/
# https://sourceforge.net/projects/msys2/files/REPOS/MSYS2/Sources/guile-2.0.14-1.src.tar.gz/download
MSYS2_GUILE_VERSION_RELEASE="${GUILE_VERSION}-1"
MSYS2_GUILE_FOLDER_NAME="guile-${MSYS2_GUILE_VERSION_RELEASE}"
local msys2_guile_archive="${MSYS2_GUILE_FOLDER_NAME}.src.tar.gz"
local msys2_guile_url="${MSYS2_GUILE_PACK_URL_BASE}/REPOS/MSYS2/Sources/${msys2_guile_archive}"
local guile_archive="${GUILE_FOLDER_NAME}.tar.gz"
local guile_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-guile-installed"
if [ ! -f "${guile_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
# download_and_extract "${guile_url}" "${guile_archive}" "${GUILE_FOLDER_NAME}"
if [ ! -f "${WORK_FOLDER_PATH}/msys2/guile/${guile_archive}" ]
then
(
mkdir -p "${WORK_FOLDER_PATH}/msys2"
cd "${WORK_FOLDER_PATH}/msys2"
download_and_extract "${msys2_guile_url}" "${msys2_guile_archive}" "guile"
)
fi
if [ ! -d "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}" ]
then
(
cd "${WORK_FOLDER_PATH}"
echo
echo "Unpacking ${guile_archive}..."
tar -xvf "${WORK_FOLDER_PATH}/msys2/guile/${guile_archive}"
cd "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}"
patch -p1 -i "${WORK_FOLDER_PATH}"/msys2/guile/guile-2.2.2-msys2.patch
xbb_activate
cp -rf build-aux/snippet "${WORK_FOLDER_PATH}"/msys2/guile/snippet
autoreconf -fi
cp -f "${WORK_FOLDER_PATH}"/msys2/guile/snippet/*.* build-aux/snippet/
)
fi
# Native build.
(
mkdir -p "${BUILD_FOLDER_PATH}-native/${GUILE_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}-native/${GUILE_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running native guile configure..."
bash "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}"/configure --help
export CFLAGS="${EXTRA_CFLAGS} -Wno-implicit-fallthrough -Wno-unused-but-set-variable -Wno-shift-count-overflow"
export CPPFLAGS="-I${INSTALL_FOLDER_PATH}-native/include"
export LDFLAGS="-L${INSTALL_FOLDER_PATH}-native/lib"
# Without it, two GC definitions will have conflicting defs.
export LIBS="-lpthread"
export PKG_CONFIG_LIBDIR="${INSTALL_FOLDER_PATH}-native"/lib/pkgconfig
bash "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}"/configure \
--prefix="${INSTALL_FOLDER_PATH}-native" \
\
--build=${BUILD} \
--host=${BUILD} \
--target=${BUILD} \
\
--disable-shared \
--enable-static \
\
--disable-rpath \
--disable-nls \
--disable-error-on-warning \
--with-threads \
--with-libiconv-prefix="${INSTALL_FOLDER_PATH}-native" \
--with-libunistring-prefix="${INSTALL_FOLDER_PATH}-native" \
| tee "${INSTALL_FOLDER_PATH}"/configure-native-guile-output.txt
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-native-guile-log.txt
fi
echo
echo "Running native guile make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}"/make-native-guile-output.txt
)
# Cross build.
(
mkdir -p "${BUILD_FOLDER_PATH}/${GUILE_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${GUILE_FOLDER_NAME}"
xbb_activate
if [ ! -f "config.status" ]
then
echo
echo "Running guile configure..."
bash "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}/configure" --help
export CFLAGS="${EXTRA_CFLAGS} -Wno-implicit-fallthrough -Wno-unused-but-set-variable -Wno-shift-count-overflow -Wno-implicit-function-declaration -Wno-return-type -Wno-unused-function -Wno-pointer-to-int-cast"
export CPPFLAGS="${EXTRA_CPPFLAGS}"
export LDFLAGS="${EXTRA_LDFLAGS}"
export GUILE_FOR_BUILD="${INSTALL_FOLDER_PATH}-native"/bin/guile
# Config inspired from msys2, but with threads, without nls.
# --disable-networking due to missing netinet/tcp.h
bash "${WORK_FOLDER_PATH}/${GUILE_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static \
\
--disable-nls \
--with-threads \
\
--disable-debug-malloc \
--disable-guile-debug \
--disable-error-on-warning \
--disable-rpath \
--enable-deprecated \
--enable-networking \
--enable-posix \
--enable-regex \
--with-modules \
\
| tee "${INSTALL_FOLDER_PATH}/configure-guile-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-guile-log.txt
fi
echo
echo "Running guile make..."
(
# Build.
make -j ${JOBS}
make install-strip
) | tee "${INSTALL_FOLDER_PATH}/make-guile-output.txt"
)
touch "${guile_stamp_file_path}"
else
echo "Library guile already installed."
fi
}
# -----------------------------------------------------------------------------

35
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/defs-source.sh Normal file
View File

@ -0,0 +1,35 @@
# -----------------------------------------------------------------------------
# This file is part of the GNU MCU Eclipse distribution.
# (https://gnu-mcu-eclipse.github.io)
# Copyright (c) 2019 Liviu Ionescu.
#
# Permission to use, copy, modify, and/or distribute this software
# for any purpose is hereby granted, under the terms of the MIT license.
# -----------------------------------------------------------------------------
# Helper script used in the second edition of the build scripts.
# As the name implies, it should contain only definitions and should
# be included with 'source' by the host and container scripts.
# Warning: MUST NOT depend on $HOME or other environment variables.
# -----------------------------------------------------------------------------
# Used to display the application name.
APP_NAME=${APP_NAME:-"Windows Build Tools"}
# Used as part of file/folder paths.
APP_UC_NAME=${APP_UC_NAME:-"Build Tools"}
APP_LC_NAME=${APP_LC_NAME:-"windows-build-tools"}
DISTRO_UC_NAME=${DISTRO_UC_NAME:-"GNU MCU Eclipse"}
DISTRO_LC_NAME=${DISTRO_LC_NAME:-"gnu-mcu-eclipse"}
# TODO: remove it.
DISTRO_INFO_NAME=${DISTRO_INFO_NAME:-"${DISTRO_LC_NAME}"}
CONTAINER_SCRIPT_NAME=${CONTAINER_SCRIPT_NAME:-"container-build.sh"}
CONTAINER_LIBS_FUNCTIONS_SCRIPT_NAME=${CONTAINER_LIBS_FUNCTIONS_SCRIPT_NAME:-"container-libs-functions-source.sh"}
CONTAINER_APPS_FUNCTIONS_SCRIPT_NAME=${CONTAINER_APPS_FUNCTIONS_SCRIPT_NAME:-"container-apps-functions-source.sh"}
# -----------------------------------------------------------------------------

21
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/LICENSE Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2017 Liviu Ionescu
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

54
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/README.md Normal file
View File

@ -0,0 +1,54 @@
# build-helper
Common script used in other build scripts.
- `host-functions-source.sh`: to be included with `source` in the host build script
- `container-functions-source.sh`: to be included with `source` in the container build script
Deprecated:
- `builder-helper.sh`: used in the first generation of build scripts.
# Patches
The code used to download and extract archives can also be used
to post-patch the downloaded files. For this a patch file must be
placed in the `patches` folder, and the name must be passed as the
third param to `extract()`.
## Memo
The code to apply the patch (`common-functions-source.sh:extract()`) does
the following:
```console
$ cd sources/binutils
$ patch -p0 < "binutils-2.31.patch"
```
The patch is applied from the library source folder, so it must be created
with the library relative path.
For example, to create a binutils patch, use:
```console
$ cd sources/binutils
$ cp bfd/ihex.c bfd/ihex-patched.c
$ vi bfd/ihex-patched.c
$ diff -u bfd/ihex.c bfd/ihex-patched.c > patches/binutils-2.31.patch
```
There may also be git patches; they are applied with `git apply file.git-patch`.
To create a patch with the uncommitted changes:
```console
$ git diff > file.git-patch
```
Links:
- https://git-scm.com/docs/git-diff
- https://git-scm.com/docs/git-apply

1761
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/common-functions-source.sh Normal file
View File

File diff suppressed because it is too large Load Diff

160
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/container-functions-source.sh Normal file
View File

@ -0,0 +1,160 @@
# -----------------------------------------------------------------------------
# Helper script used in the second edition of the GNU MCU Eclipse build
# scripts. As the name implies, it should contain only functions and
# should be included with 'source' by the container build scripts.
# -----------------------------------------------------------------------------
function start_timer()
{
CONTAINER_BEGIN_SECOND=$(date +%s)
echo
echo "Container script \"$0\" started at $(date)."
}
function stop_timer()
{
local end_second=$(date +%s)
echo
echo "Container script \"$0\" completed at $(date)."
local delta_seconds=$((end_second-CONTAINER_BEGIN_SECOND))
if [ ${delta_seconds} -lt 100 ]
then
echo "Duration: ${delta_seconds} seconds."
else
local delta_minutes=$(((delta_seconds+30)/60))
echo "Duration: ${delta_minutes} minutes."
fi
}
# -----------------------------------------------------------------------------
function detect_container()
{
echo
uname -a
CONTAINER_DISTRO_NAME=""
CONTAINER_UNAME="$(uname)"
CONTAINER_NODE_PLATFORM=""
CONTAINER_NODE_ARCH=""
if [ "${CONTAINER_UNAME}" == "Darwin" ]
then
CONTAINER_BITS="64"
CONTAINER_MACHINE="x86_64"
CONTAINER_NODE_PLATFORM="darwin"
CONTAINER_NODE_ARCH="x64"
CONTAINER_DISTRO_NAME=Darwin
CONTAINER_DISTRO_LC_NAME=darwin
elif [ "${CONTAINER_UNAME}" == "Linux" ]
then
# ----- Determine distribution name and word size -----
set +e
CONTAINER_DISTRO_NAME=$(lsb_release -si)
set -e
CONTAINER_NODE_PLATFORM="linux"
CONTAINER_NODE_ARCH="x64"
if [ -z "${CONTAINER_DISTRO_NAME}" ]
then
echo "Please install the lsb core package and rerun."
CONTAINER_DISTRO_NAME="Linux"
fi
CONTAINER_MACHINE="$(uname -m)"
if [ "${CONTAINER_MACHINE}" == "x86_64" ]
then
CONTAINER_BITS="64"
CONTAINER_NODE_ARCH="x64"
elif [ "${CONTAINER_MACHINE}" == "i686" ]
then
CONTAINER_BITS="32"
CONTAINER_NODE_ARCH="x32"
else
echo "Unknown uname -m ${CONTAINER_MACHINE}"
exit 1
fi
CONTAINER_DISTRO_LC_NAME=$(echo ${CONTAINER_DISTRO_NAME} | tr "[:upper:]" "[:lower:]")
else
echo "Unknown uname ${CONTAINER_UNAME}"
exit 1
fi
echo
echo "Container script running on ${CONTAINER_DISTRO_NAME} ${CONTAINER_BITS}-bit."
echo "User $(whoami), in '${HOME}'"
HAS_WINPTHREAD=${HAS_WINPTHREAD:-""}
CONTAINER_ROOT_UMASK=${CONTAINER_ROOT_UMASK:-"000"}
if [ -f "/.dockerenv" -a "$(whoami)" == "root" ]
then
umask ${CONTAINER_ROOT_UMASK}
fi
}
# -----------------------------------------------------------------------------
function fix_ownership()
{
if [ -f "/.dockerenv" -a "${CONTAINER_RUN_AS_ROOT}" == "y" ]
then
(
xbb_activate
# Set the owner of the folder and files created by the docker CentOS
# container to match the user running the build script on the host.
# When running on linux host, these folders and their content remain
# owned by root if this is not done. However, on macOS
# the owner used by Docker is the same as the macOS user, so an
# ownership change is not realy necessary.
echo
echo "Changing ownership to non-root GNU/Linux user..."
if [ -d "${BUILD_FOLDER_PATH}" ]
then
chown -R ${USER_ID}:${GROUP_ID} "${BUILD_FOLDER_PATH}"
fi
if [ -d "${INSTALL_FOLDER_PATH}" ]
then
chown -R ${USER_ID}:${GROUP_ID} "${INSTALL_FOLDER_PATH}"
fi
chown -R ${USER_ID}:${GROUP_ID} "${DEPLOY_FOLDER_PATH}"
)
fi
}
# -----------------------------------------------------------------------------
# Hack to make pdftex ignore errors.
# Used for newlib manuals, which issue some errors, but the
# pdf file is generated anyway.
function hack_pdfetex()
{
local bin=$(which pdfetex)
local hacked_pdfetex="hack/pdfetex"
mkdir -p "$(dirname "${hacked_pdfetex}")"
rm -rf "${hacked_pdfetex}"
echo '#!/usr/bin/env bash' >"${hacked_pdfetex}"
echo 'set -x' >>"${hacked_pdfetex}"
echo 'set +e' >>"${hacked_pdfetex}"
echo "${bin}" '$@' >>"${hacked_pdfetex}"
echo 'set -e' >>"${hacked_pdfetex}"
echo 'true' >>"${hacked_pdfetex}"
chmod +x "${hacked_pdfetex}"
export PATH="$(pwd)/$(dirname "${hacked_pdfetex}"):${PATH}"
}

952
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/host-functions-source.sh Normal file
View File

@ -0,0 +1,952 @@
# -----------------------------------------------------------------------------
# Helper script used in the second edition of the GNU MCU Eclipse build
# scripts. As the name implies, it should contain only functions and
# should be included with 'source' by the host build scripts.
# -----------------------------------------------------------------------------
function host_get_current_date()
{
# Use the UTC date as version in the name of the distribution file.
DISTRIBUTION_FILE_DATE=${DISTRIBUTION_FILE_DATE:-$(date -u +%Y%m%d-%H%M)}
# Leave a track of the start date, in case of resume needed.
mkdir -p "${HOST_WORK_FOLDER_PATH}"
touch "${HOST_WORK_FOLDER_PATH}/${DISTRIBUTION_FILE_DATE}"
echo
echo "DISTRIBUTION_FILE_DATE=\"${DISTRIBUTION_FILE_DATE}\""
}
function host_start_timer()
{
HOST_BEGIN_SECOND=$(date +%s)
echo
echo "Script \"$0\" started at $(date)."
}
function host_stop_timer()
{
local host_end_second=$(date +%s)
echo
echo "Script \"$0\" completed at $(date)."
local delta_seconds=$((host_end_second-HOST_BEGIN_SECOND))
if [ ${delta_seconds} -lt 100 ]
then
echo "Duration: ${delta_seconds} seconds."
else
local delta_minutes=$(((delta_seconds+30)/60))
echo "Duration: ${delta_minutes} minutes."
fi
}
function host_notify_completed()
{
if [ "${HOST_UNAME}" == "Darwin" ]
then
say "Wake up, the build completed successfully"
fi
}
# -----------------------------------------------------------------------------
# Detect the machine the build runs on.
function host_detect()
{
echo
uname -a
HOST_UNAME="$(uname)"
HOST_MACHINE="$(uname -m)"
HOST_DISTRO_NAME="?" # Linux distribution name (Ubuntu|CentOS|...)
HOST_DISTRO_LC_NAME="?" # Same, in lower case.
HOST_NODE_ARCH="?" # Node.js process.arch (x32|x64|arm|arm64)
HOST_NODE_PLATFORM="?" # Node.js process.platform (darwin|linux|win32)
if [ "${HOST_UNAME}" == "Darwin" ]
then
# uname -p -> i386
# uname -m -> x86_64
HOST_BITS="64"
HOST_DISTRO_NAME=Darwin
HOST_DISTRO_LC_NAME=darwin
HOST_NODE_ARCH="x64" # For now.
HOST_NODE_PLATFORM="darwin"
elif [ "${HOST_UNAME}" == "Linux" ]
then
# ----- Determine distribution name and word size -----
# uname -p -> x86_64|i686 (unknown in recent versions, use -m)
# uname -m -> x86_64|i686
if [ "${HOST_MACHINE}" == "x86_64" ]
then
HOST_BITS="64"
HOST_NODE_ARCH="x64"
elif [ "${HOST_MACHINE}" == "i686" ]
then
HOST_BITS="32"
HOST_NODE_ARCH="x32"
else
echo "Unknown uname -m ${HOST_MACHINE}"
exit 1
fi
HOST_NODE_PLATFORM="linux"
local lsb_path=$(which lsb_release)
if [ -z "${lsb_path}" ]
then
echo "Please install the lsb core package and rerun."
exit 1
fi
HOST_DISTRO_NAME=$(lsb_release -si)
HOST_DISTRO_LC_NAME=$(echo ${HOST_DISTRO_NAME} | tr "[:upper:]" "[:lower:]")
else
echo "Unsupported uname ${HOST_UNAME}"
exit 1
fi
echo
echo "Running on ${HOST_DISTRO_NAME} ${HOST_BITS}-bit."
USER_ID=$(id -u)
USER_NAME="$(id -u -n)"
GROUP_ID=$(id -g)
GROUP_NAME="$(id -g -n)"
TARGET_ARCH="${HOST_NODE_ARCH}"
TARGET_PLATFORM="${HOST_NODE_PLATFORM}"
IS_NATIVE=""
# Redefine it to "y" to run as root inside the container.
CONTAINER_RUN_AS_ROOT=${CONTAINER_RUN_AS_ROOT:-""}
HAS_WINPTHREAD=${HAS_WINPTHREAD:-""}
}
# -----------------------------------------------------------------------------
function host_prepare_cache()
{
# The folder that caches all downloads is in HOME
if [ "$(uname)" == "Darwin" ]
then
HOST_CACHE_FOLDER_PATH=${HOST_CACHE_FOLDER_PATH:-"${HOME}/Library/Caches/XBB"}
CONTAINER_CACHE_FOLDER_PATH="/Host${HOME}/Library/Caches/XBB"
else
HOST_CACHE_FOLDER_PATH=${HOST_CACHE_FOLDER_PATH:-"${HOME}/.cache/XBB"}
CONTAINER_CACHE_FOLDER_PATH="/Host${HOST_CACHE_FOLDER_PATH}"
fi
mkdir -p "${HOST_CACHE_FOLDER_PATH}"
}
function host_options()
{
local help_message="$1"
shift
ACTION=""
DO_BUILD_WIN32=""
DO_BUILD_WIN64=""
DO_BUILD_LINUX32=""
DO_BUILD_LINUX64=""
DO_BUILD_OSX=""
ENV_FILE=""
argc=$#
declare -a argv
argv=( $@ )
if [ ! -z "${DEBUG}" ]
then
echo ${argv[@]-}
fi
i=0
# Must be declared by the caller.
# declare -a rest
# Identify some of the options. The rest are collected and passed
# to the container script.
while [ $i -lt $argc ]
do
arg="${argv[$i]}"
case "${arg}" in
clean|cleanall|preload-images)
ACTION="${arg}"
;;
--win32|--windows32)
DO_BUILD_WIN32="y"
;;
--win64|--windows64)
DO_BUILD_WIN64="y"
;;
--linux32)
DO_BUILD_LINUX32="y"
;;
--linux64)
DO_BUILD_LINUX64="y"
;;
--osx)
DO_BUILD_OSX="y"
;;
--all)
DO_BUILD_WIN32="y"
DO_BUILD_WIN64="y"
DO_BUILD_LINUX32="y"
DO_BUILD_LINUX64="y"
if [ "${HOST_UNAME}" == "Darwin" ]
then
DO_BUILD_OSX="y"
fi
;;
--env-file)
((++i))
ENV_FILE="${argv[$i]}"
if [ ! -f "${ENV_FILE}" ];
then
echo "The specified environment file \"${ENV_FILE}\" does not exist, exiting..."
exit 1
fi
;;
--date)
((++i))
DISTRIBUTION_FILE_DATE="${argv[$i]}"
;;
--help)
echo "Usage:"
# Some of the options are processed by the container script.
echo "${help_message}"
echo
exit 1
;;
*)
# Collect all other in an array. Append to the end.
# Will be later processed by the container script.
set +u
rest[${#rest[*]}]="$arg"
set -u
;;
esac
((++i))
done
DO_BUILD_ANY="${DO_BUILD_OSX}${DO_BUILD_LINUX64}${DO_BUILD_WIN64}${DO_BUILD_LINUX32}${DO_BUILD_WIN32}"
# The ${rest[@]} options will be passed to the inner script.
if [ ! -z "${DEBUG}" ]
then
echo ${rest[@]-}
fi
}
function host_options_windows()
{
local help_message="$1"
shift
ACTION=""
DO_BUILD_WIN32=""
DO_BUILD_WIN64=""
# Kept, since they are used in various common functions.
DO_BUILD_LINUX32=""
DO_BUILD_LINUX64=""
DO_BUILD_OSX=""
ENV_FILE=""
argc=$#
declare -a argv
argv=( $@ )
if [ ! -z "${DEBUG}" ]
then
echo ${argv[@]-}
fi
i=0
# Must be declared by the caller.
# declare -a rest
# Identify some of the options. The rest are collected and passed
# to the container script.
while [ $i -lt $argc ]
do
arg="${argv[$i]}"
case "${arg}" in
clean|cleanall|preload-images)
ACTION="${arg}"
;;
--win32|--windows32)
DO_BUILD_WIN32="y"
;;
--win64|--windows64)
DO_BUILD_WIN64="y"
;;
--all)
DO_BUILD_WIN32="y"
DO_BUILD_WIN64="y"
;;
--env-file)
((++i))
ENV_FILE="${argv[$i]}"
if [ ! -f "${ENV_FILE}" ];
then
echo "The specified environment file \"${ENV_FILE}\" does not exist, exiting..."
exit 1
fi
;;
--date)
((++i))
DISTRIBUTION_FILE_DATE="${argv[$i]}"
;;
--help)
echo "Usage:"
# Some of the options are processed by the container script.
echo "${help_message}"
echo
exit 1
;;
*)
# Collect all other in an array. Append to the end.
# Will be later processed by the container script.
set +u
rest[${#rest[*]}]="$arg"
set -u
;;
esac
((++i))
done
DO_BUILD_ANY="${DO_BUILD_WIN64}${DO_BUILD_WIN32}"
# The ${rest[@]} options will be passed to the inner script.
if [ ! -z "${DEBUG}" ]
then
echo ${rest[@]-}
fi
}
function host_native_options()
{
local help_message="$1"
shift
ACTION=""
DO_BUILD_WIN=""
IS_DEBUG=""
IS_DEVELOP=""
WITH_STRIP=""
IS_NATIVE="y"
JOBS=""
while [ $# -gt 0 ]
do
case "$1" in
clean|cleanlibs|cleanall)
ACTION="$1"
;;
--win|--windows)
DO_BUILD_WIN="y"
;;
--debug)
IS_DEBUG="y"
;;
--develop)
IS_DEVELOP="y"
;;
--jobs)
shift
JOBS=$1
;;
--help)
echo "Build a local/native GNU MCU Eclipse ARM QEMU."
echo "Usage:"
# Some of the options are processed by the container script.
echo "${help_message}"
echo
exit 0
;;
*)
echo "Unknown action/option $1"
exit 1
;;
esac
shift
done
if [ "${DO_BUILD_WIN}" == "y" ]
then
if [ "${HOST_NODE_PLATFORM}" == "linux" ]
then
TARGET_PLATFORM="win32"
else
echo "Windows cross builds are available only on GNU/Linux."
exit 1
fi
fi
}
function host_common()
{
if [ -f "${script_folder_path}/VERSION" ]
then
# When running from the distribution folder.
RELEASE_VERSION=${RELEASE_VERSION:-"$(cat "${script_folder_path}"/VERSION)"}
fi
echo
echo "Preparing release ${RELEASE_VERSION}..."
echo
defines_script_path="${script_folder_path}/defs-source.sh"
echo "Definitions source script: \"${defines_script_path}\"."
source "${defines_script_path}"
# -----------------------------------------------------------------------------
common_helper_functions_script_path="${script_folder_path}/helper/common-functions-source.sh"
echo "Common helper functions source script: \"${common_helper_functions_script_path}\"."
source "${common_helper_functions_script_path}"
# May override some of the helper/common definitions.
common_functions_script_path="${script_folder_path}/common-functions-source.sh"
if [ -f "${common_functions_script_path}" ]
then
echo "Common functions source script: \"${common_functions_script_path}\"."
source "${common_functions_script_path}"
fi
# -----------------------------------------------------------------------------
# The Work folder is in HOME.
if [ "${IS_NATIVE}" != "y" ]
then
HOST_WORK_FOLDER_PATH=${HOST_WORK_FOLDER_PATH:-"${HOME}/Work/${APP_LC_NAME}-${RELEASE_VERSION}"}
else
HOST_WORK_FOLDER_PATH=${HOST_WORK_FOLDER_PATH:-"${HOME}/Work/${APP_LC_NAME}-dev"}
fi
CONTAINER_WORK_FOLDER_PATH="/Host${HOST_WORK_FOLDER_PATH}"
SOURCES_FOLDER_PATH="${SOURCES_FOLDER_PATH:-"${HOST_WORK_FOLDER_PATH}/sources"}"
# The names of the two Docker images used for the build.
# docker run --interactive --tty ilegeul/centos:6-xbb-v2.1
docker_linux64_image=${docker_linux64_image:-"ilegeul/centos:6-xbb-v2.1"}
docker_linux32_image=${docker_linux32_image:-"ilegeul/centos32:6-xbb-v2.1"}
do_actions
host_prepare_cache
CONTAINER_BUILD_SCRIPT_REL_PATH="build.git/scripts/${CONTAINER_SCRIPT_NAME}"
echo "Container build script: \"${HOST_WORK_FOLDER_PATH}/${CONTAINER_BUILD_SCRIPT_REL_PATH}\"."
# ---------------------------------------------------------------------------
mkdir -p "${HOST_WORK_FOLDER_PATH}"
mkdir -p "${SOURCES_FOLDER_PATH}"
# ---------------------------------------------------------------------------
# Set the DISTRIBUTION_FILE_DATE.
host_get_current_date
# ---------------------------------------------------------------------------
host_start_timer
host_prepare_prerequisites
# ---------------------------------------------------------------------------
copy_build_git
}
function host_prepare_prerequisites()
{
if [ "${HOST_UNAME}" == "Darwin" ]
then
local xbb_folder
local must_install=""
if [ -d "${HOME}/opt/xbb" ]
then
xbb_folder="${HOME}/opt/xbb"
elif [ -d "${HOME}/opt/homebrew/xbb" ]
then
xbb_folder="${HOME}/opt/homebrew/xbb"
else
must_install="y"
fi
if [ ! -z "${xbb_folder}" ]
then
echo
echo "Checking XBB in '${xbb_folder}'..."
if [ ! -f "${xbb_folder}/xbb-source.sh" ]
then
must_install="y"
fi
fi
if [ -n "${must_install}" ]
then
echo
echo "Please install the macOS XBB and rerun."
echo "https://github.com/xpack/xpack-build-box/tree/master/macos"
exit 1
fi
if true
then
local tl_folder="$HOME/opt/texlive"
must_install=""
# Check local TeX Live.
if [ ! -d "${tl_folder}" ]
then
must_install="y"
else
PATH="${tl_folder}/bin/x86_64-darwin:${PATH}"
export PATH
echo
echo "Checking TeX Live in '${tl_folder}'..."
set +e
tex --version | grep 'TeX 3'
if [ $? != 0 ]
then
must_install="y"
fi
set -e
fi
if [ -n "${must_install}" ]
then
echo
echo "Please install TeX Live and rerun."
echo "Alternatively restart the build script using '--without-pdf'."
echo "https://github.com/xpack/xpack-build-box/blob/master/macos/README.md#install-tex"
exit 1
fi
fi # -z "${no_pdf}"
fi # "${HOST_UNAME}" == "Darwin"
host_prepare_cache
# The host script will pass to the container script
# various environment variables.
HOST_DEFINES_SCRIPT_PATH="${HOST_WORK_FOLDER_PATH}/build.git/scripts/host-defs-source.sh"
DEPLOY_FOLDER_NAME=${DEPLOY_FOLDER_NAME:-"deploy"}
}
# -----------------------------------------------------------------------------
function host_prepare_docker()
{
echo
echo "Checking Docker..."
set +e
docker --version
if [ $? != 0 ]
then
echo "Please start docker daemon and rerun."
echo "If not installed, see https://docs.docker.com/installation/."
exit 1
fi
set -e
}
# -----------------------------------------------------------------------------
function host_build_target()
{
message="$1"
shift
echo
echo "================================================================================"
echo "=== ${message}"
echo
echo $@
local container_script_path=""
local target_platform="${HOST_NODE_PLATFORM}"
local target_arch="${HOST_NODE_ARCH}"
local target_bits="${HOST_BITS}"
# If the docker image is not set, it is a native build.
local docker_image=""
local build_binaries_path=""
local env_file=""
while [ $# -gt 0 ]
do
case "$1" in
--script)
container_script_path="$2"
shift 2
;;
--target-platform)
target_platform="$2"
shift 2
;;
--target-arch)
target_arch="$2"
shift 2
;;
--target-bits)
target_bits="$2"
shift 2
;;
--docker-image)
docker_image="$2"
shift 2
;;
--env-file)
env_file="$2"
shift 2
;;
--)
shift
break
;;
*)
echo "Unknown option $1, exit."
exit 1
esac
done
# The remaining $@ options will be passed to the inner script.
if [ -n "${DEBUG}" ]
then
echo $@
fi
# ---------------------------------------------------------------------------
mkdir -p "$(dirname "${HOST_DEFINES_SCRIPT_PATH}")"
echo "${RELEASE_VERSION}" >"$(dirname "${HOST_DEFINES_SCRIPT_PATH}")"/VERSION
rm -rf "${HOST_DEFINES_SCRIPT_PATH}"
touch "${HOST_DEFINES_SCRIPT_PATH}"
echo "RELEASE_VERSION=\"${RELEASE_VERSION}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "DISTRIBUTION_FILE_DATE=\"${DISTRIBUTION_FILE_DATE}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "TARGET_PLATFORM=\"${target_platform}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "TARGET_ARCH=\"${target_arch}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "TARGET_BITS=\"${target_bits}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "HOST_UNAME=\"${HOST_UNAME}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "USER_ID=\"${USER_ID}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "USER_NAME=\"${USER_NAME}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "GROUP_ID=\"${GROUP_ID}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "GROUP_NAME=\"${GROUP_NAME}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "CONTAINER_RUN_AS_ROOT=\"${CONTAINER_RUN_AS_ROOT}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "HOST_WORK_FOLDER_PATH=\"${HOST_WORK_FOLDER_PATH}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "CONTAINER_WORK_FOLDER_PATH=\"${CONTAINER_WORK_FOLDER_PATH}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "HOST_CACHE_FOLDER_PATH=\"${HOST_CACHE_FOLDER_PATH}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "CONTAINER_CACHE_FOLDER_PATH=\"${CONTAINER_CACHE_FOLDER_PATH}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
echo "DEPLOY_FOLDER_NAME=\"${DEPLOY_FOLDER_NAME}\"" >>"${HOST_DEFINES_SCRIPT_PATH}"
if [ -z "${docker_image}" ]
then
host_run_native_script \
--script "${container_script_path}" \
--env-file "${env_file}" \
-- \
$@
else
host_run_docker_script \
--script "${container_script_path}" \
--docker-image "${docker_image}" \
--docker-container-name "${APP_LC_NAME}-${target_platform}-${target_arch}-build" \
--env-file "${env_file}" \
--host-uname "${HOST_UNAME}" \
-- \
$@
fi
if [ -n "${DEBUG}" ]
then
echo "host_build_target ${rest[@]-} completed."
fi
}
# -----------------------------------------------------------------------------
function host_run_native_script()
{
local local_script=""
local env_file=""
while [ $# -gt 0 ]
do
case "$1" in
--script)
local_script="$2"
shift 2
;;
--env-file)
env_file="$2"
shift 2
;;
--)
shift
break
;;
*)
echo "Unknown option $1, exit."
exit 1
esac
done
# The remaining $@ options will be passed to the inner script.
echo
echo "Running script \"$(basename "${local_script}")\" natively..."
# Run the inner script in a local sub-shell, possibly with the
# custom environment.
(
if [ -n "${env_file}" -a -f "${env_file}" ]
then
source "${env_file}"
fi
/bin/bash ${DEBUG} "${local_script}" $@
)
}
# -----------------------------------------------------------------------------
function host_run_docker_script()
{
local docker_script=""
local docker_image=""
local docker_container_name=""
local host_uname=""
local env_file=""
local opt_env_file=
while [ $# -gt 0 ]
do
case "$1" in
--script)
docker_script="$2"
shift 2
;;
--docker-image)
docker_image="$2"
shift 2
;;
--docker-container-name)
docker_container_name="$2"
shift 2
;;
--host-uname)
host_uname="$2"
shift 2
;;
--env-file)
env_file="$2"
shift 2
;;
--)
shift
break
;;
*)
echo "Unknown option $1, exit."
exit 1
esac
done
set +e
# Remove a possible previously crashed container.
docker rm --force "${docker_container_name}" > /dev/null 2> /dev/null
set -e
echo
echo "Running script \"$(basename "${docker_script}")\" inside docker image \"${docker_image}\"..."
local env_file_option=""
# Run the inner script in a fresh Docker container.
if [ -n "${env_file}" -a -f "${env_file}" ]
then
env_file_option="--env-file=\"${env_file}\""
fi
if [ "${CONTAINER_RUN_AS_ROOT}" == "y" ]
then
docker run \
--name="${docker_container_name}" \
--tty \
--hostname "docker" \
--workdir="/root" \
--volume="${HOST_WORK_FOLDER_PATH}/:${CONTAINER_WORK_FOLDER_PATH}" \
--volume="${HOST_CACHE_FOLDER_PATH}/:${CONTAINER_CACHE_FOLDER_PATH}" \
${env_file_option} \
"${docker_image}" \
/bin/bash ${DEBUG} "${docker_script}" $@
else
# This is a bit tricky, since it needs to do multiple actions in
# one go: add a new user and run the script with that user credentials,
# including passing the extra args (in the middle of the string).
#
# From the [bash manual](https://www.gnu.org/software/bash/manual/bash.html):
# ($*) Expands to the positional parameters, starting from one.
# When the expansion is not within double quotes, each positional
# parameter expands to a separate word. In contexts where it is
# performed, those words are subject to further word splitting and
# pathname expansion. When the expansion occurs within double quotes,
# it expands to a single word with the value of each parameter separated
# by the first character of the IFS special variable. That is, "$*"
# is equivalent to "$1c$2c…", where c is the first character of the
# value of the IFS variable. If IFS is unset, the parameters are
# separated by spaces. If IFS is null, the parameters are joined
# without intervening separators.
local ifs="${IFS}"
IFS=" "
local cmd_string="groupadd -g ${GROUP_ID} ${GROUP_NAME} && useradd -u ${USER_ID} -g ${GROUP_ID} ${USER_NAME} && su -c \"DEBUG=${DEBUG} bash ${docker_script} $*\" ${USER_NAME}"
IFS="${ifs}"
docker run \
--name="${docker_container_name}" \
--tty \
--hostname "docker" \
--workdir="/root" \
--volume="${HOST_WORK_FOLDER_PATH}/:${CONTAINER_WORK_FOLDER_PATH}" \
--volume="${HOST_CACHE_FOLDER_PATH}/:${CONTAINER_CACHE_FOLDER_PATH}" \
${env_file_option} \
"${docker_image}" \
/bin/bash ${DEBUG} -c "${cmd_string}"
fi
# Remove the container.
echo "Docker container \"$(docker rm --force "${docker_container_name}")\" removed."
}
# -----------------------------------------------------------------------------
function host_show_sha() {
if [ -d "${HOST_WORK_FOLDER_PATH}/${DEPLOY_FOLDER_NAME}" ]
then
echo
echo "SHA signatures..."
set +e
cat "${HOST_WORK_FOLDER_PATH}/${DEPLOY_FOLDER_NAME}"/*.sha
set -e
fi
}
# -----------------------------------------------------------------------------

77
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/helper/templates.sh Normal file
View File

@ -0,0 +1,77 @@
# Templates to be used with copy/paste in the bash source files.
# Build xxx library.
function do_xxx()
{
# XXX_VERSION="1.1"
XXX_SRC_FOLDER_NAME="xxx-${XXX_VERSION}"
XXX_FOLDER_NAME="${XXX_SRC_FOLDER_NAME}"
local xxx_archive="${XXX_SRC_FOLDER_NAME}.tar.gz"
local xxx_url="http://.../${xxx_archive}"
local xxx_stamp_file_path="${INSTALL_FOLDER_PATH}/stamp-xxx-installed"
if [ ! -f "${xxx_stamp_file_path}" ]
then
cd "${WORK_FOLDER_PATH}"
download_and_extract "${xxx_url}" "${xxx_archive}" \
"${XXX_SRC_FOLDER_NAME}"
(
mkdir -p "${BUILD_FOLDER_PATH}/${XXX_FOLDER_NAME}"
cd "${BUILD_FOLDER_PATH}/${XXX_FOLDER_NAME}"
xbb_activate
export CFLAGS="${XBB_CFLAGS}"
export CPPFLAGS="${XBB_CPPFLAGS}"
export LDFLAGS="${XBB_LDFLAGS}"
if [ ! -f "config.status" ]
then
echo
echo "Running xxx configure..."
(
bash "${WORK_FOLDER_PATH}/${XXX_SRC_FOLDER_NAME}/configure" --help
bash "${WORK_FOLDER_PATH}/${XXX_SRC_FOLDER_NAME}/configure" \
--prefix="${INSTALL_FOLDER_PATH}" \
\
--build=${BUILD} \
--host=${HOST} \
--target=${TARGET} \
\
--disable-shared \
--enable-static
) 2>&1 | tee "${INSTALL_FOLDER_PATH}/configure-xxx-output.txt"
cp "config.log" "${INSTALL_FOLDER_PATH}"/config-xxx-log.txt
fi
echo
echo "Running xxx make..."
(
# Build.
make -j ${JOBS}
if [ "${WITH_STRIP}" == "y" ]
then
make install-strip
else
make install
fi
) 2>&1 | tee "${INSTALL_FOLDER_PATH}/make-xxx-output.txt"
)
touch "${xxx_stamp_file_path}"
else
echo "Library xxx already installed."
fi
}

16
tools/BuildTools/2.12-20190422-1053/gnu-mcu-eclipse/scripts/host-defs-source.sh Normal file
View File

@ -0,0 +1,16 @@
RELEASE_VERSION="2.12"
DISTRIBUTION_FILE_DATE="20190422-1053"
TARGET_PLATFORM="win32"
TARGET_ARCH="x64"
TARGET_BITS="64"
HOST_UNAME="Darwin"
USER_ID="501"
USER_NAME="ilg"
GROUP_ID="20"
GROUP_NAME="staff"
CONTAINER_RUN_AS_ROOT="y"
HOST_WORK_FOLDER_PATH="/Users/ilg/Work/windows-build-tools-2.12"
CONTAINER_WORK_FOLDER_PATH="/Host/Users/ilg/Work/windows-build-tools-2.12"
HOST_CACHE_FOLDER_PATH="/Users/ilg/Library/Caches/XBB"
CONTAINER_CACHE_FOLDER_PATH="/Host/Users/ilg/Library/Caches/XBB"
DEPLOY_FOLDER_NAME="deploy"