diff options
Diffstat (limited to 'meta/classes/libc-package.bbclass')
-rw-r--r-- | meta/classes/libc-package.bbclass | 384 |
1 files changed, 0 insertions, 384 deletions
diff --git a/meta/classes/libc-package.bbclass b/meta/classes/libc-package.bbclass deleted file mode 100644 index de3b4250c7..0000000000 --- a/meta/classes/libc-package.bbclass +++ /dev/null | |||
@@ -1,384 +0,0 @@ | |||
1 | # | ||
2 | # This class knows how to package up [e]glibc. Its shared since prebuild binary toolchains | ||
3 | # may need packaging and its pointless to duplicate this code. | ||
4 | # | ||
5 | # Caller should set GLIBC_INTERNAL_USE_BINARY_LOCALE to one of: | ||
6 | # "compile" - Use QEMU to generate the binary locale files | ||
7 | # "precompiled" - The binary locale files are pregenerated and already present | ||
8 | # "ondevice" - The device will build the locale files upon first boot through the postinst | ||
9 | |||
10 | GLIBC_INTERNAL_USE_BINARY_LOCALE ?= "ondevice" | ||
11 | |||
12 | GLIBC_SPLIT_LC_PACKAGES ?= "0" | ||
13 | |||
14 | python __anonymous () { | ||
15 | enabled = d.getVar("ENABLE_BINARY_LOCALE_GENERATION") | ||
16 | |||
17 | pn = d.getVar("PN") | ||
18 | if pn.endswith("-initial"): | ||
19 | enabled = False | ||
20 | |||
21 | if enabled and int(enabled): | ||
22 | import re | ||
23 | |||
24 | target_arch = d.getVar("TARGET_ARCH") | ||
25 | binary_arches = d.getVar("BINARY_LOCALE_ARCHES") or "" | ||
26 | use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF") or "" | ||
27 | |||
28 | for regexp in binary_arches.split(" "): | ||
29 | r = re.compile(regexp) | ||
30 | |||
31 | if r.match(target_arch): | ||
32 | depends = d.getVar("DEPENDS") | ||
33 | if use_cross_localedef == "1" : | ||
34 | depends = "%s cross-localedef-native" % depends | ||
35 | else: | ||
36 | depends = "%s qemu-native" % depends | ||
37 | d.setVar("DEPENDS", depends) | ||
38 | d.setVar("GLIBC_INTERNAL_USE_BINARY_LOCALE", "compile") | ||
39 | break | ||
40 | } | ||
41 | |||
42 | # try to fix disable charsets/locales/locale-code compile fail | ||
43 | PACKAGE_NO_GCONV ?= "0" | ||
44 | |||
45 | OVERRIDES_append = ":${TARGET_ARCH}-${TARGET_OS}" | ||
46 | |||
47 | locale_base_postinst_ontarget() { | ||
48 | localedef --inputfile=${datadir}/i18n/locales/%s --charmap=%s %s | ||
49 | } | ||
50 | |||
51 | locale_base_postrm() { | ||
52 | #!/bin/sh | ||
53 | localedef --delete-from-archive --inputfile=${datadir}/locales/%s --charmap=%s %s | ||
54 | } | ||
55 | |||
56 | LOCALETREESRC ?= "${PKGD}" | ||
57 | |||
58 | do_prep_locale_tree() { | ||
59 | treedir=${WORKDIR}/locale-tree | ||
60 | rm -rf $treedir | ||
61 | mkdir -p $treedir/${base_bindir} $treedir/${base_libdir} $treedir/${datadir} $treedir/${localedir} | ||
62 | tar -cf - -C ${LOCALETREESRC}${datadir} -p i18n | tar -xf - -C $treedir/${datadir} | ||
63 | # unzip to avoid parsing errors | ||
64 | for i in $treedir/${datadir}/i18n/charmaps/*gz; do | ||
65 | gunzip $i | ||
66 | done | ||
67 | # The extract pattern "./l*.so*" is carefully selected so that it will | ||
68 | # match ld*.so and lib*.so*, but not any files in the gconv directory | ||
69 | # (if it exists). This makes sure we only unpack the files we need. | ||
70 | # This is important in case usrmerge is set in DISTRO_FEATURES, which | ||
71 | # means ${base_libdir} == ${libdir}. | ||
72 | tar -cf - -C ${LOCALETREESRC}${base_libdir} -p . | tar -xf - -C $treedir/${base_libdir} --wildcards './l*.so*' | ||
73 | if [ -f ${STAGING_LIBDIR_NATIVE}/libgcc_s.* ]; then | ||
74 | tar -cf - -C ${STAGING_LIBDIR_NATIVE} -p libgcc_s.* | tar -xf - -C $treedir/${base_libdir} | ||
75 | fi | ||
76 | install -m 0755 ${LOCALETREESRC}${bindir}/localedef $treedir/${base_bindir} | ||
77 | } | ||
78 | |||
79 | do_collect_bins_from_locale_tree() { | ||
80 | treedir=${WORKDIR}/locale-tree | ||
81 | |||
82 | parent=$(dirname ${localedir}) | ||
83 | mkdir -p ${PKGD}/$parent | ||
84 | tar -cf - -C $treedir/$parent -p $(basename ${localedir}) | tar -xf - -C ${PKGD}$parent | ||
85 | |||
86 | # Finalize tree by chaning all duplicate files into hard links | ||
87 | cross-localedef-hardlink -c -v ${WORKDIR}/locale-tree | ||
88 | } | ||
89 | |||
90 | inherit qemu | ||
91 | |||
92 | python package_do_split_gconvs () { | ||
93 | import re | ||
94 | if (d.getVar('PACKAGE_NO_GCONV') == '1'): | ||
95 | bb.note("package requested not splitting gconvs") | ||
96 | return | ||
97 | |||
98 | if not d.getVar('PACKAGES'): | ||
99 | return | ||
100 | |||
101 | mlprefix = d.getVar("MLPREFIX") or "" | ||
102 | |||
103 | bpn = d.getVar('BPN') | ||
104 | libdir = d.getVar('libdir') | ||
105 | if not libdir: | ||
106 | bb.error("libdir not defined") | ||
107 | return | ||
108 | datadir = d.getVar('datadir') | ||
109 | if not datadir: | ||
110 | bb.error("datadir not defined") | ||
111 | return | ||
112 | |||
113 | gconv_libdir = oe.path.join(libdir, "gconv") | ||
114 | charmap_dir = oe.path.join(datadir, "i18n", "charmaps") | ||
115 | locales_dir = oe.path.join(datadir, "i18n", "locales") | ||
116 | binary_locales_dir = d.getVar('localedir') | ||
117 | |||
118 | def calc_gconv_deps(fn, pkg, file_regex, output_pattern, group): | ||
119 | deps = [] | ||
120 | f = open(fn, "rb") | ||
121 | c_re = re.compile(r'^copy "(.*)"') | ||
122 | i_re = re.compile(r'^include "(\w+)".*') | ||
123 | for l in f.readlines(): | ||
124 | l = l.decode("latin-1") | ||
125 | m = c_re.match(l) or i_re.match(l) | ||
126 | if m: | ||
127 | dp = legitimize_package_name('%s%s-gconv-%s' % (mlprefix, bpn, m.group(1))) | ||
128 | if not dp in deps: | ||
129 | deps.append(dp) | ||
130 | f.close() | ||
131 | if deps != []: | ||
132 | d.setVar('RDEPENDS_%s' % pkg, " ".join(deps)) | ||
133 | if bpn != 'glibc': | ||
134 | d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc')) | ||
135 | |||
136 | do_split_packages(d, gconv_libdir, file_regex=r'^(.*)\.so$', output_pattern=bpn+'-gconv-%s', \ | ||
137 | description='gconv module for character set %s', hook=calc_gconv_deps, \ | ||
138 | extra_depends=bpn+'-gconv') | ||
139 | |||
140 | def calc_charmap_deps(fn, pkg, file_regex, output_pattern, group): | ||
141 | deps = [] | ||
142 | f = open(fn, "rb") | ||
143 | c_re = re.compile(r'^copy "(.*)"') | ||
144 | i_re = re.compile(r'^include "(\w+)".*') | ||
145 | for l in f.readlines(): | ||
146 | l = l.decode("latin-1") | ||
147 | m = c_re.match(l) or i_re.match(l) | ||
148 | if m: | ||
149 | dp = legitimize_package_name('%s%s-charmap-%s' % (mlprefix, bpn, m.group(1))) | ||
150 | if not dp in deps: | ||
151 | deps.append(dp) | ||
152 | f.close() | ||
153 | if deps != []: | ||
154 | d.setVar('RDEPENDS_%s' % pkg, " ".join(deps)) | ||
155 | if bpn != 'glibc': | ||
156 | d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc')) | ||
157 | |||
158 | do_split_packages(d, charmap_dir, file_regex=r'^(.*)\.gz$', output_pattern=bpn+'-charmap-%s', \ | ||
159 | description='character map for %s encoding', hook=calc_charmap_deps, extra_depends='') | ||
160 | |||
161 | def calc_locale_deps(fn, pkg, file_regex, output_pattern, group): | ||
162 | deps = [] | ||
163 | f = open(fn, "rb") | ||
164 | c_re = re.compile(r'^copy "(.*)"') | ||
165 | i_re = re.compile(r'^include "(\w+)".*') | ||
166 | for l in f.readlines(): | ||
167 | l = l.decode("latin-1") | ||
168 | m = c_re.match(l) or i_re.match(l) | ||
169 | if m: | ||
170 | dp = legitimize_package_name(mlprefix+bpn+'-localedata-%s' % m.group(1)) | ||
171 | if not dp in deps: | ||
172 | deps.append(dp) | ||
173 | f.close() | ||
174 | if deps != []: | ||
175 | d.setVar('RDEPENDS_%s' % pkg, " ".join(deps)) | ||
176 | if bpn != 'glibc': | ||
177 | d.setVar('RPROVIDES_%s' % pkg, pkg.replace(bpn, 'glibc')) | ||
178 | |||
179 | do_split_packages(d, locales_dir, file_regex=r'(.*)', output_pattern=bpn+'-localedata-%s', \ | ||
180 | description='locale definition for %s', hook=calc_locale_deps, extra_depends='') | ||
181 | d.setVar('PACKAGES', d.getVar('PACKAGES', False) + ' ' + d.getVar('MLPREFIX', False) + bpn + '-gconv') | ||
182 | |||
183 | use_bin = d.getVar("GLIBC_INTERNAL_USE_BINARY_LOCALE") | ||
184 | |||
185 | dot_re = re.compile(r"(.*)\.(.*)") | ||
186 | |||
187 | # Read in supported locales and associated encodings | ||
188 | supported = {} | ||
189 | with open(oe.path.join(d.getVar('WORKDIR'), "SUPPORTED")) as f: | ||
190 | for line in f.readlines(): | ||
191 | try: | ||
192 | locale, charset = line.rstrip().split() | ||
193 | except ValueError: | ||
194 | continue | ||
195 | supported[locale] = charset | ||
196 | |||
197 | # GLIBC_GENERATE_LOCALES var specifies which locales to be generated. empty or "all" means all locales | ||
198 | to_generate = d.getVar('GLIBC_GENERATE_LOCALES') | ||
199 | if not to_generate or to_generate == 'all': | ||
200 | to_generate = sorted(supported.keys()) | ||
201 | else: | ||
202 | to_generate = to_generate.split() | ||
203 | for locale in to_generate: | ||
204 | if locale not in supported: | ||
205 | if '.' in locale: | ||
206 | charset = locale.split('.')[1] | ||
207 | else: | ||
208 | charset = 'UTF-8' | ||
209 | bb.warn("Unsupported locale '%s', assuming encoding '%s'" % (locale, charset)) | ||
210 | supported[locale] = charset | ||
211 | |||
212 | def output_locale_source(name, pkgname, locale, encoding): | ||
213 | d.setVar('RDEPENDS_%s' % pkgname, '%slocaledef %s-localedata-%s %s-charmap-%s' % \ | ||
214 | (mlprefix, mlprefix+bpn, legitimize_package_name(locale), mlprefix+bpn, legitimize_package_name(encoding))) | ||
215 | d.setVar('pkg_postinst_ontarget_%s' % pkgname, d.getVar('locale_base_postinst_ontarget') \ | ||
216 | % (locale, encoding, locale)) | ||
217 | d.setVar('pkg_postrm_%s' % pkgname, d.getVar('locale_base_postrm') % \ | ||
218 | (locale, encoding, locale)) | ||
219 | |||
220 | def output_locale_binary_rdepends(name, pkgname, locale, encoding): | ||
221 | dep = legitimize_package_name('%s-binary-localedata-%s' % (bpn, name)) | ||
222 | lcsplit = d.getVar('GLIBC_SPLIT_LC_PACKAGES') | ||
223 | if lcsplit and int(lcsplit): | ||
224 | d.appendVar('PACKAGES', ' ' + dep) | ||
225 | d.setVar('ALLOW_EMPTY_%s' % dep, '1') | ||
226 | d.setVar('RDEPENDS_%s' % pkgname, mlprefix + dep) | ||
227 | |||
228 | commands = {} | ||
229 | |||
230 | def output_locale_binary(name, pkgname, locale, encoding): | ||
231 | treedir = oe.path.join(d.getVar("WORKDIR"), "locale-tree") | ||
232 | ldlibdir = oe.path.join(treedir, d.getVar("base_libdir")) | ||
233 | path = d.getVar("PATH") | ||
234 | i18npath = oe.path.join(treedir, datadir, "i18n") | ||
235 | gconvpath = oe.path.join(treedir, "iconvdata") | ||
236 | outputpath = oe.path.join(treedir, binary_locales_dir) | ||
237 | |||
238 | use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF") or "0" | ||
239 | if use_cross_localedef == "1": | ||
240 | target_arch = d.getVar('TARGET_ARCH') | ||
241 | locale_arch_options = { \ | ||
242 | "arc": " --uint32-align=4 --little-endian ", \ | ||
243 | "arceb": " --uint32-align=4 --big-endian ", \ | ||
244 | "arm": " --uint32-align=4 --little-endian ", \ | ||
245 | "armeb": " --uint32-align=4 --big-endian ", \ | ||
246 | "aarch64": " --uint32-align=4 --little-endian ", \ | ||
247 | "aarch64_be": " --uint32-align=4 --big-endian ", \ | ||
248 | "sh4": " --uint32-align=4 --big-endian ", \ | ||
249 | "powerpc": " --uint32-align=4 --big-endian ", \ | ||
250 | "powerpc64": " --uint32-align=4 --big-endian ", \ | ||
251 | "powerpc64le": " --uint32-align=4 --little-endian ", \ | ||
252 | "mips": " --uint32-align=4 --big-endian ", \ | ||
253 | "mipsisa32r6": " --uint32-align=4 --big-endian ", \ | ||
254 | "mips64": " --uint32-align=4 --big-endian ", \ | ||
255 | "mipsisa64r6": " --uint32-align=4 --big-endian ", \ | ||
256 | "mipsel": " --uint32-align=4 --little-endian ", \ | ||
257 | "mipsisa32r6el": " --uint32-align=4 --little-endian ", \ | ||
258 | "mips64el":" --uint32-align=4 --little-endian ", \ | ||
259 | "mipsisa64r6el":" --uint32-align=4 --little-endian ", \ | ||
260 | "riscv64": " --uint32-align=4 --little-endian ", \ | ||
261 | "riscv32": " --uint32-align=4 --little-endian ", \ | ||
262 | "i586": " --uint32-align=4 --little-endian ", \ | ||
263 | "i686": " --uint32-align=4 --little-endian ", \ | ||
264 | "x86_64": " --uint32-align=4 --little-endian " } | ||
265 | |||
266 | if target_arch in locale_arch_options: | ||
267 | localedef_opts = locale_arch_options[target_arch] | ||
268 | else: | ||
269 | bb.error("locale_arch_options not found for target_arch=" + target_arch) | ||
270 | bb.fatal("unknown arch:" + target_arch + " for locale_arch_options") | ||
271 | |||
272 | localedef_opts += " --force --no-hard-links --no-archive --prefix=%s \ | ||
273 | --inputfile=%s/%s/i18n/locales/%s --charmap=%s %s/%s" \ | ||
274 | % (treedir, treedir, datadir, locale, encoding, outputpath, name) | ||
275 | |||
276 | cmd = "PATH=\"%s\" I18NPATH=\"%s\" GCONV_PATH=\"%s\" cross-localedef %s" % \ | ||
277 | (path, i18npath, gconvpath, localedef_opts) | ||
278 | else: # earlier slower qemu way | ||
279 | qemu = qemu_target_binary(d) | ||
280 | localedef_opts = "--force --no-hard-links --no-archive --prefix=%s \ | ||
281 | --inputfile=%s/i18n/locales/%s --charmap=%s %s" \ | ||
282 | % (treedir, datadir, locale, encoding, name) | ||
283 | |||
284 | qemu_options = d.getVar('QEMU_OPTIONS') | ||
285 | |||
286 | cmd = "PSEUDO_RELOADED=YES PATH=\"%s\" I18NPATH=\"%s\" %s -L %s \ | ||
287 | -E LD_LIBRARY_PATH=%s %s %s${base_bindir}/localedef %s" % \ | ||
288 | (path, i18npath, qemu, treedir, ldlibdir, qemu_options, treedir, localedef_opts) | ||
289 | |||
290 | commands["%s/%s" % (outputpath, name)] = cmd | ||
291 | |||
292 | bb.note("generating locale %s (%s)" % (locale, encoding)) | ||
293 | |||
294 | def output_locale(name, locale, encoding): | ||
295 | pkgname = d.getVar('MLPREFIX', False) + 'locale-base-' + legitimize_package_name(name) | ||
296 | d.setVar('ALLOW_EMPTY_%s' % pkgname, '1') | ||
297 | d.setVar('PACKAGES', '%s %s' % (pkgname, d.getVar('PACKAGES'))) | ||
298 | rprovides = ' %svirtual-locale-%s' % (mlprefix, legitimize_package_name(name)) | ||
299 | m = re.match(r"(.*)_(.*)", name) | ||
300 | if m: | ||
301 | rprovides += ' %svirtual-locale-%s' % (mlprefix, m.group(1)) | ||
302 | d.setVar('RPROVIDES_%s' % pkgname, rprovides) | ||
303 | |||
304 | if use_bin == "compile": | ||
305 | output_locale_binary_rdepends(name, pkgname, locale, encoding) | ||
306 | output_locale_binary(name, pkgname, locale, encoding) | ||
307 | elif use_bin == "precompiled": | ||
308 | output_locale_binary_rdepends(name, pkgname, locale, encoding) | ||
309 | else: | ||
310 | output_locale_source(name, pkgname, locale, encoding) | ||
311 | |||
312 | if use_bin == "compile": | ||
313 | bb.note("preparing tree for binary locale generation") | ||
314 | bb.build.exec_func("do_prep_locale_tree", d) | ||
315 | |||
316 | utf8_only = int(d.getVar('LOCALE_UTF8_ONLY') or 0) | ||
317 | utf8_is_default = int(d.getVar('LOCALE_UTF8_IS_DEFAULT') or 0) | ||
318 | |||
319 | encodings = {} | ||
320 | for locale in to_generate: | ||
321 | charset = supported[locale] | ||
322 | if utf8_only and charset != 'UTF-8': | ||
323 | continue | ||
324 | |||
325 | m = dot_re.match(locale) | ||
326 | if m: | ||
327 | base = m.group(1) | ||
328 | else: | ||
329 | base = locale | ||
330 | |||
331 | # Non-precompiled locales may be renamed so that the default | ||
332 | # (non-suffixed) encoding is always UTF-8, i.e., instead of en_US and | ||
333 | # en_US.UTF-8, we have en_US and en_US.ISO-8859-1. This implicitly | ||
334 | # contradicts SUPPORTED. | ||
335 | if use_bin == "precompiled" or not utf8_is_default: | ||
336 | output_locale(locale, base, charset) | ||
337 | else: | ||
338 | if charset == 'UTF-8': | ||
339 | output_locale(base, base, charset) | ||
340 | else: | ||
341 | output_locale('%s.%s' % (base, charset), base, charset) | ||
342 | |||
343 | def metapkg_hook(file, pkg, pattern, format, basename): | ||
344 | name = basename.split('/', 1)[0] | ||
345 | metapkg = legitimize_package_name('%s-binary-localedata-%s' % (mlprefix+bpn, name)) | ||
346 | d.appendVar('RDEPENDS_%s' % metapkg, ' ' + pkg) | ||
347 | |||
348 | if use_bin == "compile": | ||
349 | makefile = oe.path.join(d.getVar("WORKDIR"), "locale-tree", "Makefile") | ||
350 | with open(makefile, "w") as m: | ||
351 | m.write("all: %s\n\n" % " ".join(commands.keys())) | ||
352 | total = len(commands) | ||
353 | for i, (maketarget, makerecipe) in enumerate(commands.items()): | ||
354 | m.write(maketarget + ":\n") | ||
355 | m.write("\t@echo 'Progress %d/%d'\n" % (i, total)) | ||
356 | m.write("\t" + makerecipe + "\n\n") | ||
357 | d.setVar("EXTRA_OEMAKE", "-C %s ${PARALLEL_MAKE}" % (os.path.dirname(makefile))) | ||
358 | d.setVarFlag("oe_runmake", "progress", "outof:Progress\s(\d+)/(\d+)") | ||
359 | bb.note("Executing binary locale generation makefile") | ||
360 | bb.build.exec_func("oe_runmake", d) | ||
361 | bb.note("collecting binary locales from locale tree") | ||
362 | bb.build.exec_func("do_collect_bins_from_locale_tree", d) | ||
363 | |||
364 | if use_bin in ('compile', 'precompiled'): | ||
365 | lcsplit = d.getVar('GLIBC_SPLIT_LC_PACKAGES') | ||
366 | if lcsplit and int(lcsplit): | ||
367 | do_split_packages(d, binary_locales_dir, file_regex=r'^(.*/LC_\w+)', \ | ||
368 | output_pattern=bpn+'-binary-localedata-%s', \ | ||
369 | description='binary locale definition for %s', recursive=True, | ||
370 | hook=metapkg_hook, extra_depends='', allow_dirs=True, match_path=True) | ||
371 | else: | ||
372 | do_split_packages(d, binary_locales_dir, file_regex=r'(.*)', \ | ||
373 | output_pattern=bpn+'-binary-localedata-%s', \ | ||
374 | description='binary locale definition for %s', extra_depends='', allow_dirs=True) | ||
375 | else: | ||
376 | bb.note("generation of binary locales disabled. this may break i18n!") | ||
377 | |||
378 | } | ||
379 | |||
380 | # We want to do this indirection so that we can safely 'return' | ||
381 | # from the called function even though we're prepending | ||
382 | python populate_packages_prepend () { | ||
383 | bb.build.exec_func('package_do_split_gconvs', d) | ||
384 | } | ||