2005-08-31 10:45:47 +00:00
|
|
|
#
|
2010-08-06 02:38:06 +00:00
|
|
|
# This class knows how to package up [e]glibc. Its shared since prebuild binary toolchains
|
2009-11-19 22:37:45 +00:00
|
|
|
# may need packaging and its pointless to duplicate this code.
|
2005-08-31 10:45:47 +00:00
|
|
|
#
|
2009-11-19 22:37:45 +00:00
|
|
|
# Caller should set GLIBC_INTERNAL_USE_BINARY_LOCALE to one of:
|
|
|
|
# "compile" - Use QEMU to generate the binary locale files
|
|
|
|
# "precompiled" - The binary locale files are pregenerated and already present
|
|
|
|
# "ondevice" - The device will build the locale files upon first boot through the postinst
|
2006-04-12 16:05:04 +00:00
|
|
|
|
2009-11-19 22:37:45 +00:00
|
|
|
GLIBC_INTERNAL_USE_BINARY_LOCALE ?= "ondevice"
|
2006-04-12 16:05:04 +00:00
|
|
|
|
2010-10-04 20:31:23 +00:00
|
|
|
python __anonymous () {
|
2011-11-25 14:25:16 +00:00
|
|
|
enabled = d.getVar("ENABLE_BINARY_LOCALE_GENERATION", True)
|
2010-10-04 20:31:23 +00:00
|
|
|
|
2011-02-17 00:17:01 +00:00
|
|
|
pn = d.getVar("PN", True)
|
|
|
|
if pn.endswith("-initial"):
|
|
|
|
enabled = False
|
|
|
|
|
2010-10-04 20:31:23 +00:00
|
|
|
if enabled and int(enabled):
|
|
|
|
import re
|
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
target_arch = d.getVar("TARGET_ARCH", True)
|
|
|
|
binary_arches = d.getVar("BINARY_LOCALE_ARCHES", True) or ""
|
|
|
|
use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF", True) or ""
|
2010-10-04 20:31:23 +00:00
|
|
|
|
|
|
|
for regexp in binary_arches.split(" "):
|
|
|
|
r = re.compile(regexp)
|
|
|
|
|
|
|
|
if r.match(target_arch):
|
2011-11-25 14:25:16 +00:00
|
|
|
depends = d.getVar("DEPENDS", True)
|
2010-10-04 20:31:23 +00:00
|
|
|
if use_cross_localedef == "1" :
|
|
|
|
depends = "%s cross-localedef-native" % depends
|
|
|
|
else:
|
|
|
|
depends = "%s qemu-native" % depends
|
Convert to use direct access to the data store (instead of bb.data.*Var*())
This is the result of running the following over the metadata:
sed \
-e 's:bb.data.\(setVar([^,()]*,[^,()]*\), *\([^ )]*\) *):\2.\1):g' \
-e 's:bb.data.\(setVarFlag([^,()]*,[^,()]*,[^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^() ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-i `grep -ril bb.data *`
(From OE-Core rev: b22831fd63164c4db9c0b72934d7d734a6585251)
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2011-11-09 15:00:01 +00:00
|
|
|
d.setVar("DEPENDS", depends)
|
|
|
|
d.setVar("GLIBC_INTERNAL_USE_BINARY_LOCALE", "compile")
|
2010-10-04 20:31:23 +00:00
|
|
|
break
|
eglibc packaging: locale packaging configuration
The PACKAGE_NO_GCONV var manipulations ware happening in the
eglibc-options.inc file, and the eglibc-locale recipe do not
see it. Moving that into the libc-package.bbclass which is
common to eglibc & eglibc-locale recipes.
This fixes bug: [YOCTO #2089]
This avoids this error for poky-tiny
NOTE: package eglibc-locale-2.13-r19: task do_populate_sysroot: Started
ERROR: Error executing a python function in
/opt/poky.git/meta/recipes-core/eglibc/eglibc-locale_2.13.bb:
OSError: [Errno 2] No such file or directory:
'/home/rchatre/concordia/dev/ccd-distro-work/tmp/work/core2-poky-linux/eglibc-locale-2.13-r19/package/usr/lib/gconv'
ERROR: The stack trace of python calls that resulted in this exception/failure
was:
ERROR: File "package_do_split_gconvs", line 264, in <module>
ERROR:·
ERROR: File "package_do_split_gconvs", line 45, in package_do_split_gconvs
ERROR:·
ERROR: File "package.bbclass", line 30, in do_split_packages
ERROR:·
ERROR: The code that was being executed was:
ERROR: 0260:»------»-------bb.note("generation of binary locales disabled.
this may break i18n!")
ERROR: 0261:
ERROR: 0262:
ERROR: 0263:
ERROR: *** 0264:package_do_split_gconvs(d)
ERROR: 0265:
ERROR: (file: 'package_do_split_gconvs', lineno: 264, function: <module>)
ERROR: 0041:»------»-------»-------d.setVar('RPROVIDES_%s' % pkg,
pkg.replace(bpn, 'glibc'))
ERROR: 0042:
ERROR: 0043:»------do_split_packages(d, gconv_libdir,
file_regex='^(.*)\.so$', output_pattern=bpn+'-gconv-%s', \
ERROR: 0044:»------»-------description='gconv module for character set
%s', hook=calc_gconv_deps, \
ERROR: *** 0045:»------»-------extra_depends=bpn+'-gconv')
ERROR: 0046:
ERROR: 0047:»------def calc_charmap_deps(fn, pkg, file_regex,
output_pattern, group):
ERROR: 0048:»------»-------deps = []
ERROR: 0049:»------»-------f = open(fn, "r")
ERROR: (file: 'package_do_split_gconvs', lineno: 45, function:
package_do_split_gconvs)
ERROR: Function failed: package_do_split_gconvs
ERROR: Logfile of failure stored in:
/home/rchatre/concordia/dev/ccd-distro-work/tmp/work/core2-poky-linux/eglibc-locale-2.13-r19/temp/log.do_package.31042
NOTE: package eglibc-locale-2.13-r19: task do_package: Failed
ERROR: Task 552 (/opt/poky.git/meta/recipes-core/eglibc/eglibc-locale_2.13.bb,
do_package) failed with exit code '1'
Signed-Off-By: Nitin A Kamble <nitin.a.kamble@intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-03-30 20:59:18 +00:00
|
|
|
|
|
|
|
distro_features = (d.getVar('DISTRO_FEATURES', True) or '').split()
|
|
|
|
|
|
|
|
# try to fix disable charsets/locales/locale-code compile fail
|
|
|
|
if 'libc-charsets' in distro_features and 'libc-locales' in distro_features and 'libc-locale-code' in distro_features:
|
|
|
|
d.setVar('PACKAGE_NO_GCONV', '0')
|
|
|
|
else:
|
|
|
|
d.setVar('PACKAGE_NO_GCONV', '1')
|
2010-10-04 20:31:23 +00:00
|
|
|
}
|
2010-08-06 02:38:06 +00:00
|
|
|
|
|
|
|
OVERRIDES_append = ":${TARGET_ARCH}-${TARGET_OS}"
|
|
|
|
|
|
|
|
do_configure_prepend() {
|
2012-01-27 17:13:43 +00:00
|
|
|
if [ -e ${S}/elf/ldd.bash.in ]; then
|
|
|
|
sed -e "s#@BASH@#/bin/sh#" -i ${S}/elf/ldd.bash.in
|
|
|
|
fi
|
2010-08-06 02:38:06 +00:00
|
|
|
}
|
|
|
|
|
2005-08-31 10:45:47 +00:00
|
|
|
|
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
# indentation removed on purpose
|
2005-08-31 10:45:47 +00:00
|
|
|
locale_base_postinst() {
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
if [ "x$D" != "x" ]; then
|
2010-08-06 02:38:06 +00:00
|
|
|
exit 1
|
2005-08-31 10:45:47 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
rm -rf ${TMP_LOCALE}
|
|
|
|
mkdir -p ${TMP_LOCALE}
|
|
|
|
if [ -f ${libdir}/locale/locale-archive ]; then
|
|
|
|
cp ${libdir}/locale/locale-archive ${TMP_LOCALE}/
|
|
|
|
fi
|
|
|
|
localedef --inputfile=${datadir}/i18n/locales/%s --charmap=%s --prefix=/tmp/locale %s
|
2006-08-18 09:31:38 +00:00
|
|
|
mkdir -p ${libdir}/locale/
|
2005-08-31 10:45:47 +00:00
|
|
|
mv ${TMP_LOCALE}/locale-archive ${libdir}/locale/
|
|
|
|
rm -rf ${TMP_LOCALE}
|
|
|
|
}
|
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
# indentation removed on purpose
|
2005-08-31 10:45:47 +00:00
|
|
|
locale_base_postrm() {
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
rm -rf ${TMP_LOCALE}
|
|
|
|
mkdir -p ${TMP_LOCALE}
|
|
|
|
if [ -f ${libdir}/locale/locale-archive ]; then
|
|
|
|
cp ${libdir}/locale/locale-archive ${TMP_LOCALE}/
|
|
|
|
fi
|
|
|
|
localedef --delete-from-archive --inputfile=${datadir}/locales/%s --charmap=%s --prefix=/tmp/locale %s
|
|
|
|
mv ${TMP_LOCALE}/locale-archive ${libdir}/locale/
|
|
|
|
rm -rf ${TMP_LOCALE}
|
|
|
|
}
|
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
|
|
|
|
TMP_LOCALE="/tmp/locale${libdir}/locale"
|
2012-01-27 17:13:39 +00:00
|
|
|
LOCALETREESRC ?= "${PKGD}"
|
2010-08-06 02:38:06 +00:00
|
|
|
|
2006-04-12 16:05:04 +00:00
|
|
|
do_prep_locale_tree() {
|
|
|
|
treedir=${WORKDIR}/locale-tree
|
|
|
|
rm -rf $treedir
|
2011-02-09 04:16:41 +00:00
|
|
|
mkdir -p $treedir/${base_bindir} $treedir/${base_libdir} $treedir/${datadir} $treedir/${libdir}/locale
|
2011-06-29 12:04:40 +00:00
|
|
|
tar -cf - -C ${LOCALETREESRC}${datadir} -ps i18n | tar -xf - -C $treedir/${datadir}
|
2006-04-12 16:05:04 +00:00
|
|
|
# unzip to avoid parsing errors
|
|
|
|
for i in $treedir/${datadir}/i18n/charmaps/*gz; do
|
|
|
|
gunzip $i
|
|
|
|
done
|
2011-06-29 12:04:40 +00:00
|
|
|
tar -cf - -C ${LOCALETREESRC}${base_libdir} -ps . | tar -xf - -C $treedir/${base_libdir}
|
2010-04-22 14:20:05 +00:00
|
|
|
if [ -f ${STAGING_DIR_NATIVE}${prefix_native}/lib/libgcc_s.* ]; then
|
2011-02-09 04:16:41 +00:00
|
|
|
tar -cf - -C ${STAGING_DIR_NATIVE}/${prefix_native}/${base_libdir} -ps libgcc_s.* | tar -xf - -C $treedir/${base_libdir}
|
2006-04-12 16:05:04 +00:00
|
|
|
fi
|
2011-06-29 12:04:40 +00:00
|
|
|
install -m 0755 ${LOCALETREESRC}${bindir}/localedef $treedir/${base_bindir}
|
2006-04-12 16:05:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
do_collect_bins_from_locale_tree() {
|
|
|
|
treedir=${WORKDIR}/locale-tree
|
|
|
|
|
2009-11-09 23:21:56 +00:00
|
|
|
mkdir -p ${PKGD}${libdir}
|
2011-02-09 04:16:41 +00:00
|
|
|
tar -cf - -C $treedir/${libdir} -ps locale | tar -xf - -C ${PKGD}${libdir}
|
2006-04-12 16:05:04 +00:00
|
|
|
}
|
2006-02-10 12:06:32 +00:00
|
|
|
|
2010-10-04 20:31:23 +00:00
|
|
|
inherit qemu
|
|
|
|
|
2005-08-31 10:45:47 +00:00
|
|
|
python package_do_split_gconvs () {
|
|
|
|
import os, re
|
2011-11-25 14:25:16 +00:00
|
|
|
if (d.getVar('PACKAGE_NO_GCONV', True) == '1'):
|
2005-08-31 10:45:47 +00:00
|
|
|
bb.note("package requested not splitting gconvs")
|
|
|
|
return
|
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
if not d.getVar('PACKAGES', True):
|
2005-08-31 10:45:47 +00:00
|
|
|
return
|
|
|
|
|
2012-04-23 08:48:59 +00:00
|
|
|
mlprefix = d.getVar("MLPREFIX", True) or ""
|
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
bpn = d.getVar('BPN', True)
|
|
|
|
libdir = d.getVar('libdir', True)
|
2005-08-31 10:45:47 +00:00
|
|
|
if not libdir:
|
|
|
|
bb.error("libdir not defined")
|
|
|
|
return
|
2011-11-25 14:25:16 +00:00
|
|
|
datadir = d.getVar('datadir', True)
|
2005-08-31 10:45:47 +00:00
|
|
|
if not datadir:
|
|
|
|
bb.error("datadir not defined")
|
|
|
|
return
|
|
|
|
|
2007-11-17 23:20:31 +00:00
|
|
|
gconv_libdir = base_path_join(libdir, "gconv")
|
|
|
|
charmap_dir = base_path_join(datadir, "i18n", "charmaps")
|
|
|
|
locales_dir = base_path_join(datadir, "i18n", "locales")
|
|
|
|
binary_locales_dir = base_path_join(libdir, "locale")
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
def calc_gconv_deps(fn, pkg, file_regex, output_pattern, group):
|
|
|
|
deps = []
|
|
|
|
f = open(fn, "r")
|
|
|
|
c_re = re.compile('^copy "(.*)"')
|
|
|
|
i_re = re.compile('^include "(\w+)".*')
|
|
|
|
for l in f.readlines():
|
|
|
|
m = c_re.match(l) or i_re.match(l)
|
|
|
|
if m:
|
2012-04-23 08:48:59 +00:00
|
|
|
dp = legitimize_package_name('%s%s-gconv-%s' % (mlprefix, bpn, m.group(1)))
|
2010-08-06 02:38:06 +00:00
|
|
|
if not dp in deps:
|
|
|
|
deps.append(dp)
|
|
|
|
f.close()
|
|
|
|
if deps != []:
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RDEPENDS_%s' % pkg, " ".join(deps))
|
2010-08-06 02:38:06 +00:00
|
|
|
if bpn != 'glibc':
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc'))
|
2010-08-06 02:38:06 +00:00
|
|
|
|
|
|
|
do_split_packages(d, gconv_libdir, file_regex='^(.*)\.so$', output_pattern=bpn+'-gconv-%s', \
|
|
|
|
description='gconv module for character set %s', hook=calc_gconv_deps, \
|
|
|
|
extra_depends=bpn+'-gconv')
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
def calc_charmap_deps(fn, pkg, file_regex, output_pattern, group):
|
|
|
|
deps = []
|
|
|
|
f = open(fn, "r")
|
|
|
|
c_re = re.compile('^copy "(.*)"')
|
|
|
|
i_re = re.compile('^include "(\w+)".*')
|
|
|
|
for l in f.readlines():
|
|
|
|
m = c_re.match(l) or i_re.match(l)
|
|
|
|
if m:
|
2012-04-23 08:48:59 +00:00
|
|
|
dp = legitimize_package_name('%s%s-charmap-%s' % (mlprefix, bpn, m.group(1)))
|
2010-08-06 02:38:06 +00:00
|
|
|
if not dp in deps:
|
|
|
|
deps.append(dp)
|
|
|
|
f.close()
|
|
|
|
if deps != []:
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RDEPENDS_%s' % pkg, " ".join(deps))
|
2010-08-06 02:38:06 +00:00
|
|
|
if bpn != 'glibc':
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc'))
|
2010-08-06 02:38:06 +00:00
|
|
|
|
|
|
|
do_split_packages(d, charmap_dir, file_regex='^(.*)\.gz$', output_pattern=bpn+'-charmap-%s', \
|
|
|
|
description='character map for %s encoding', hook=calc_charmap_deps, extra_depends='')
|
2005-08-31 10:45:47 +00:00
|
|
|
|
|
|
|
def calc_locale_deps(fn, pkg, file_regex, output_pattern, group):
|
|
|
|
deps = []
|
|
|
|
f = open(fn, "r")
|
|
|
|
c_re = re.compile('^copy "(.*)"')
|
|
|
|
i_re = re.compile('^include "(\w+)".*')
|
|
|
|
for l in f.readlines():
|
|
|
|
m = c_re.match(l) or i_re.match(l)
|
|
|
|
if m:
|
2012-04-23 08:48:59 +00:00
|
|
|
dp = legitimize_package_name(mlprefix+bpn+'-localedata-%s' % m.group(1))
|
2005-08-31 10:45:47 +00:00
|
|
|
if not dp in deps:
|
|
|
|
deps.append(dp)
|
|
|
|
f.close()
|
|
|
|
if deps != []:
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RDEPENDS_%s' % pkg, " ".join(deps))
|
2010-08-06 02:38:06 +00:00
|
|
|
if bpn != 'glibc':
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc'))
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2010-08-06 02:38:06 +00:00
|
|
|
do_split_packages(d, locales_dir, file_regex='(.*)', output_pattern=bpn+'-localedata-%s', \
|
|
|
|
description='locale definition for %s', hook=calc_locale_deps, extra_depends='')
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('PACKAGES', d.getVar('PACKAGES') + ' ' + d.getVar('MLPREFIX') + bpn + '-gconv')
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
use_bin = d.getVar("GLIBC_INTERNAL_USE_BINARY_LOCALE", True)
|
2005-08-31 10:45:47 +00:00
|
|
|
|
|
|
|
dot_re = re.compile("(.*)\.(.*)")
|
|
|
|
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
# Read in supported locales and associated encodings
|
|
|
|
supported = {}
|
|
|
|
with open(base_path_join(d.getVar('WORKDIR', True), "SUPPORTED")) as f:
|
|
|
|
for line in f.readlines():
|
|
|
|
try:
|
|
|
|
locale, charset = line.rstrip().split()
|
|
|
|
except ValueError:
|
|
|
|
continue
|
|
|
|
supported[locale] = charset
|
|
|
|
|
|
|
|
# GLIBC_GENERATE_LOCALES var specifies which locales to be generated. empty or "all" means all locales
|
|
|
|
to_generate = d.getVar('GLIBC_GENERATE_LOCALES', True)
|
|
|
|
if not to_generate or to_generate == 'all':
|
|
|
|
to_generate = supported.keys()
|
2009-11-20 15:50:34 +00:00
|
|
|
else:
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
to_generate = to_generate.split()
|
|
|
|
for locale in to_generate:
|
|
|
|
if locale not in supported:
|
|
|
|
if '.' in locale:
|
|
|
|
charset = locale.split('.')[1]
|
|
|
|
else:
|
|
|
|
charset = 'UTF-8'
|
|
|
|
bb.warn("Unsupported locale '%s', assuming encoding '%s'" % (locale, charset))
|
|
|
|
supported[locale] = charset
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2009-11-20 15:50:34 +00:00
|
|
|
def output_locale_source(name, pkgname, locale, encoding):
|
2011-12-01 12:51:01 +00:00
|
|
|
d.setVar('RDEPENDS_%s' % pkgname, 'localedef %s-localedata-%s %s-charmap-%s' % \
|
2012-04-23 08:48:59 +00:00
|
|
|
(mlprefix+bpn, legitimize_package_name(locale), mlprefix+bpn, legitimize_package_name(encoding)))
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('pkg_postinst_%s' % pkgname, d.getVar('locale_base_postinst', True) \
|
|
|
|
% (locale, encoding, locale))
|
|
|
|
d.setVar('pkg_postrm_%s' % pkgname, d.getVar('locale_base_postrm', True) % \
|
|
|
|
(locale, encoding, locale))
|
2005-08-31 10:45:47 +00:00
|
|
|
|
2009-11-20 15:50:34 +00:00
|
|
|
def output_locale_binary_rdepends(name, pkgname, locale, encoding):
|
2011-08-26 16:51:47 +00:00
|
|
|
m = re.match("(.*)\.(.*)", name)
|
2006-08-18 09:31:38 +00:00
|
|
|
if m:
|
2011-08-26 16:51:47 +00:00
|
|
|
libc_name = "%s.%s" % (m.group(1), m.group(2).lower().replace("-",""))
|
2006-08-18 09:31:38 +00:00
|
|
|
else:
|
2010-08-06 02:38:06 +00:00
|
|
|
libc_name = name
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('RDEPENDS_%s' % pkgname, legitimize_package_name('%s-binary-localedata-%s' \
|
2012-04-23 08:48:59 +00:00
|
|
|
% (mlprefix+bpn, libc_name)))
|
2006-04-12 16:05:04 +00:00
|
|
|
|
2011-10-07 12:25:44 +00:00
|
|
|
commands = {}
|
|
|
|
|
2009-11-20 15:50:34 +00:00
|
|
|
def output_locale_binary(name, pkgname, locale, encoding):
|
2011-11-25 14:25:16 +00:00
|
|
|
treedir = base_path_join(d.getVar("WORKDIR", True), "locale-tree")
|
|
|
|
ldlibdir = base_path_join(treedir, d.getVar("base_libdir", True))
|
|
|
|
path = d.getVar("PATH", True)
|
2007-11-17 23:20:31 +00:00
|
|
|
i18npath = base_path_join(treedir, datadir, "i18n")
|
2010-10-04 20:31:23 +00:00
|
|
|
gconvpath = base_path_join(treedir, "iconvdata")
|
2011-06-23 10:59:39 +00:00
|
|
|
outputpath = base_path_join(treedir, libdir, "locale")
|
2010-10-04 20:31:23 +00:00
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF", True) or "0"
|
2010-10-04 20:31:23 +00:00
|
|
|
if use_cross_localedef == "1":
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
target_arch = d.getVar('TARGET_ARCH', True)
|
2010-10-04 20:31:23 +00:00
|
|
|
locale_arch_options = { \
|
|
|
|
"arm": " --uint32-align=4 --little-endian ", \
|
2012-04-25 22:41:14 +00:00
|
|
|
"sh4": " --uint32-align=4 --big-endian ", \
|
2010-10-04 20:31:23 +00:00
|
|
|
"powerpc": " --uint32-align=4 --big-endian ", \
|
2011-07-22 09:24:53 +00:00
|
|
|
"powerpc64": " --uint32-align=4 --big-endian ", \
|
2010-10-04 20:31:23 +00:00
|
|
|
"mips": " --uint32-align=4 --big-endian ", \
|
2012-04-25 22:41:14 +00:00
|
|
|
"mips64": " --uint32-align=4 --big-endian ", \
|
2010-10-04 20:31:23 +00:00
|
|
|
"mipsel": " --uint32-align=4 --little-endian ", \
|
2012-04-25 22:41:14 +00:00
|
|
|
"mips64el":" --uint32-align=4 --little-endian ", \
|
2010-10-04 20:31:23 +00:00
|
|
|
"i586": " --uint32-align=4 --little-endian ", \
|
2012-03-29 06:48:35 +00:00
|
|
|
"i686": " --uint32-align=4 --little-endian ", \
|
2010-10-04 20:31:23 +00:00
|
|
|
"x86_64": " --uint32-align=4 --little-endian " }
|
|
|
|
|
|
|
|
if target_arch in locale_arch_options:
|
|
|
|
localedef_opts = locale_arch_options[target_arch]
|
|
|
|
else:
|
|
|
|
bb.error("locale_arch_options not found for target_arch=" + target_arch)
|
|
|
|
raise bb.build.FuncFailed("unknown arch:" + target_arch + " for locale_arch_options")
|
|
|
|
|
|
|
|
localedef_opts += " --force --old-style --no-archive --prefix=%s \
|
2011-06-23 10:59:39 +00:00
|
|
|
--inputfile=%s/%s/i18n/locales/%s --charmap=%s %s/%s" \
|
|
|
|
% (treedir, treedir, datadir, locale, encoding, outputpath, name)
|
2010-10-04 20:31:23 +00:00
|
|
|
|
|
|
|
cmd = "PATH=\"%s\" I18NPATH=\"%s\" GCONV_PATH=\"%s\" cross-localedef %s" % \
|
|
|
|
(path, i18npath, gconvpath, localedef_opts)
|
|
|
|
else: # earlier slower qemu way
|
|
|
|
qemu = qemu_target_binary(d)
|
|
|
|
localedef_opts = "--force --old-style --no-archive --prefix=%s \
|
|
|
|
--inputfile=%s/i18n/locales/%s --charmap=%s %s" \
|
|
|
|
% (treedir, datadir, locale, encoding, name)
|
|
|
|
|
2011-11-25 14:25:16 +00:00
|
|
|
qemu_options = d.getVar("QEMU_OPTIONS_%s" % d.getVar('PACKAGE_ARCH', True), True)
|
2010-10-04 20:31:23 +00:00
|
|
|
if not qemu_options:
|
2011-11-25 14:25:16 +00:00
|
|
|
qemu_options = d.getVar('QEMU_OPTIONS', True)
|
2010-10-04 20:31:23 +00:00
|
|
|
|
|
|
|
cmd = "PSEUDO_RELOADED=YES PATH=\"%s\" I18NPATH=\"%s\" %s -L %s \
|
|
|
|
-E LD_LIBRARY_PATH=%s %s %s/bin/localedef %s" % \
|
|
|
|
(path, i18npath, qemu, treedir, ldlibdir, qemu_options, treedir, localedef_opts)
|
2010-08-06 02:38:06 +00:00
|
|
|
|
2011-10-07 12:25:44 +00:00
|
|
|
commands["%s/%s" % (outputpath, name)] = cmd
|
|
|
|
|
2006-04-12 16:05:04 +00:00
|
|
|
bb.note("generating locale %s (%s)" % (locale, encoding))
|
|
|
|
|
|
|
|
def output_locale(name, locale, encoding):
|
Convert to use direct access to the data store (instead of bb.data.*Var*())
This is the result of running the following over the metadata:
sed \
-e 's:bb.data.\(setVar([^,()]*,[^,()]*\), *\([^ )]*\) *):\2.\1):g' \
-e 's:bb.data.\(setVarFlag([^,()]*,[^,()]*,[^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^() ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-i `grep -ril bb.data *`
(From OE-Core rev: b22831fd63164c4db9c0b72934d7d734a6585251)
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2011-11-09 15:00:01 +00:00
|
|
|
pkgname = d.getVar('MLPREFIX') + 'locale-base-' + legitimize_package_name(name)
|
|
|
|
d.setVar('ALLOW_EMPTY_%s' % pkgname, '1')
|
2011-11-25 14:25:16 +00:00
|
|
|
d.setVar('PACKAGES', '%s %s' % (pkgname, d.getVar('PACKAGES', True)))
|
2012-05-18 14:18:11 +00:00
|
|
|
rprovides = ' %svirtual-locale-%s' % (mlprefix, legitimize_package_name(name))
|
2009-11-20 15:50:34 +00:00
|
|
|
m = re.match("(.*)_(.*)", name)
|
|
|
|
if m:
|
2012-05-18 14:18:11 +00:00
|
|
|
rprovides += ' %svirtual-locale-%s' % (mlprefix, m.group(1))
|
Convert to use direct access to the data store (instead of bb.data.*Var*())
This is the result of running the following over the metadata:
sed \
-e 's:bb.data.\(setVar([^,()]*,[^,()]*\), *\([^ )]*\) *):\2.\1):g' \
-e 's:bb.data.\(setVarFlag([^,()]*,[^,()]*,[^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^(), ]*\) *,\([^)]*\)):\2.\1,\3):g' \
-e 's:bb.data.\(getVarFlag([^,()]*,[^,()]*\), *\([^() ]*\) *):\2.\1):g' \
-e 's:bb.data.\(getVar([^,()]*\), *\([^) ]*\) *):\2.\1):g' \
-i `grep -ril bb.data *`
(From OE-Core rev: b22831fd63164c4db9c0b72934d7d734a6585251)
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2011-11-09 15:00:01 +00:00
|
|
|
d.setVar('RPROVIDES_%s' % pkgname, rprovides)
|
2010-08-06 02:38:06 +00:00
|
|
|
|
2009-11-19 22:37:45 +00:00
|
|
|
if use_bin == "compile":
|
2009-11-20 15:50:34 +00:00
|
|
|
output_locale_binary_rdepends(name, pkgname, locale, encoding)
|
|
|
|
output_locale_binary(name, pkgname, locale, encoding)
|
|
|
|
elif use_bin == "precompiled":
|
|
|
|
output_locale_binary_rdepends(name, pkgname, locale, encoding)
|
2006-04-12 16:05:04 +00:00
|
|
|
else:
|
2009-11-20 15:50:34 +00:00
|
|
|
output_locale_source(name, pkgname, locale, encoding)
|
2006-04-12 16:05:04 +00:00
|
|
|
|
2009-11-19 22:37:45 +00:00
|
|
|
if use_bin == "compile":
|
2006-04-12 16:05:04 +00:00
|
|
|
bb.note("preparing tree for binary locale generation")
|
|
|
|
bb.build.exec_func("do_prep_locale_tree", d)
|
|
|
|
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
utf8_only = int(d.getVar('LOCALE_UTF8_ONLY', True) or 0)
|
|
|
|
encodings = {}
|
|
|
|
for locale in to_generate:
|
|
|
|
charset = supported[locale]
|
|
|
|
if utf8_only and charset != 'UTF-8':
|
|
|
|
continue
|
|
|
|
|
|
|
|
m = dot_re.match(locale)
|
|
|
|
if m:
|
|
|
|
base = m.group(1)
|
2005-08-31 10:45:47 +00:00
|
|
|
else:
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
base = locale
|
2006-08-18 09:31:38 +00:00
|
|
|
|
libc-package: rework ''precompiled' locale handling
There were a couple problems with the handling of precompiled locales.
- it gathered the list of locales from the directories - this breaks due to
the naming mismatch, e.g. en_US.UTF-8 vs en_US.utf8.
- it retained its hardcoded assumption that the non-suffixed locale (en_US, as
opposed to en_US.*) is UTF-8, while the others are otherwise. Hardcoding
this is both inflexible and just plain wrong for some toolchains. It's most
common in desktop distros for 'en_US' to be non-utf8, and ''en_US.UTF-8' is
utf8, and this is the case in some external toolchains as well.
The code now uses the SUPPORTED file to hold the knowledge it needs. This file
not only holds the list of locales to generate, but also maps the locale names
to the charsets they correspond to. The code now uses this to assemble its
charset map, falling back to the '.' suffix as charset when the locale is not
in the map. For precompiled, it now uses the locale->charset knowledge it has,
thereby allowing non-utf8 non-suffixed locale names, whereas for
non-precompiled, it reverts to the previous assumption, renaming the utf8
locale and forcibly suffixing the others.
So, a person maintaining an external toolchain recipe is responsible for
ensuring that the SUPPORTED file they provide matches up with the compiled
locales in the toolchain, if they want to utilize precompiled locales.
I believe in the long term the compiled case should do the same thing
precompiled does, and use SUPPORTED or a similar mechanism to encode the
knowledge, and if people want all the non-suffixed names to be utf8, they can
change that file to do so. This would avoid the hardcoded assumption in the
code, as well as consolidating the behavior between the compiled and
precompiled cases.
(From OE-Core rev: 3f36058923ccda25a3dd85046542e65b6034c09e)
Signed-off-by: Christopher Larson <kergoth@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
2012-04-27 04:03:55 +00:00
|
|
|
# Precompiled locales are kept as is, obeying SUPPORTED, while
|
|
|
|
# others are adjusted, ensuring that the non-suffixed locales
|
|
|
|
# are utf-8, while the suffixed are not.
|
|
|
|
if use_bin == "precompiled":
|
|
|
|
output_locale(locale, base, charset)
|
|
|
|
else:
|
|
|
|
if charset == 'UTF-8':
|
|
|
|
output_locale(base, base, charset)
|
|
|
|
else:
|
|
|
|
output_locale('%s.%s' % (base, charset), base, charset)
|
2006-04-12 16:05:04 +00:00
|
|
|
|
2009-11-19 22:37:45 +00:00
|
|
|
if use_bin == "compile":
|
2011-11-25 14:25:16 +00:00
|
|
|
makefile = base_path_join(d.getVar("WORKDIR", True), "locale-tree", "Makefile")
|
2011-10-07 12:25:44 +00:00
|
|
|
m = open(makefile, "w")
|
|
|
|
m.write("all: %s\n\n" % " ".join(commands.keys()))
|
|
|
|
for cmd in commands:
|
|
|
|
m.write(cmd + ":\n")
|
|
|
|
m.write(" " + commands[cmd] + "\n\n")
|
|
|
|
m.close()
|
|
|
|
d.setVar("B", os.path.dirname(makefile))
|
|
|
|
d.setVar("EXTRA_OEMAKE", "${PARALLEL_MAKE}")
|
|
|
|
bb.note("Executing binary locale generation makefile")
|
|
|
|
bb.build.exec_func("oe_runmake", d)
|
2006-04-12 16:05:04 +00:00
|
|
|
bb.note("collecting binary locales from locale tree")
|
|
|
|
bb.build.exec_func("do_collect_bins_from_locale_tree", d)
|
2010-08-06 02:38:06 +00:00
|
|
|
do_split_packages(d, binary_locales_dir, file_regex='(.*)', \
|
|
|
|
output_pattern=bpn+'-binary-localedata-%s', \
|
|
|
|
description='binary locale definition for %s', extra_depends='', allow_dirs=True)
|
2009-11-20 15:50:34 +00:00
|
|
|
elif use_bin == "precompiled":
|
2010-08-06 02:38:06 +00:00
|
|
|
do_split_packages(d, binary_locales_dir, file_regex='(.*)', \
|
|
|
|
output_pattern=bpn+'-binary-localedata-%s', \
|
|
|
|
description='binary locale definition for %s', extra_depends='', allow_dirs=True)
|
2006-08-18 09:31:38 +00:00
|
|
|
else:
|
|
|
|
bb.note("generation of binary locales disabled. this may break i18n!")
|
|
|
|
|
2005-08-31 10:45:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
# We want to do this indirection so that we can safely 'return'
|
|
|
|
# from the called function even though we're prepending
|
|
|
|
python populate_packages_prepend () {
|
|
|
|
bb.build.exec_func('package_do_split_gconvs', d)
|
|
|
|
}
|
2011-06-29 12:00:23 +00:00
|
|
|
|