Adding upstream version 0.0~git20250520.a1d9079+dfsg.
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
590ac7ff5f
commit
20149b7f3a
GPG key ID:
FBB4F0E80A80222F
456 changed files with 70406 additions and 0 deletions
293
internal/binres/pool.go
Normal file
293
internal/binres/pool.go
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package binres
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"unicode/utf16"
|
||||
)
|
||||
|
||||
const (
|
||||
SortedFlag uint32 = 1 << 0
|
||||
UTF8Flag = 1 << 8
|
||||
)
|
||||
|
||||
// PoolRef is the i'th string in a pool.
|
||||
type PoolRef uint32
|
||||
|
||||
// Resolve returns the string entry of PoolRef in pl.
|
||||
func (ref PoolRef) Resolve(pl *Pool) string {
|
||||
return pl.strings[ref]
|
||||
}
|
||||
|
||||
// Pool is a container for string and style span collections.
|
||||
//
|
||||
// Pool has the following structure marshalled:
|
||||
//
|
||||
// chunkHeader
|
||||
// uint32 number of strings in this pool
|
||||
// uint32 number of style spans in pool
|
||||
// uint32 SortedFlag, UTF8Flag
|
||||
// uint32 index of string data from header
|
||||
// uint32 index of style data from header
|
||||
// []uint32 string indices starting at zero
|
||||
// []uint16 or []uint8 concatenation of string entries
|
||||
//
|
||||
// UTF-16 entries are as follows:
|
||||
//
|
||||
// uint16 string length, exclusive
|
||||
// uint16 [optional] low word if high bit of length set
|
||||
// [n]byte data
|
||||
// uint16 0x0000 terminator
|
||||
//
|
||||
// UTF-8 entries are as follows:
|
||||
//
|
||||
// uint8 character length, exclusive
|
||||
// uint8 [optional] low word if high bit of character length set
|
||||
// uint8 byte length, exclusive
|
||||
// uint8 [optional] low word if high bit of byte length set
|
||||
// [n]byte data
|
||||
// uint8 0x00 terminator
|
||||
type Pool struct {
|
||||
chunkHeader
|
||||
strings []string
|
||||
styles []*Span
|
||||
flags uint32 // SortedFlag, UTF8Flag
|
||||
}
|
||||
|
||||
// ref returns the PoolRef of s, inserting s if it doesn't exist.
|
||||
func (pl *Pool) ref(s string) PoolRef {
|
||||
for i, x := range pl.strings {
|
||||
if s == x {
|
||||
return PoolRef(i)
|
||||
}
|
||||
}
|
||||
pl.strings = append(pl.strings, s)
|
||||
return PoolRef(len(pl.strings) - 1)
|
||||
}
|
||||
|
||||
// RefByName returns the PoolRef of s, or error if not exists.
|
||||
func (pl *Pool) RefByName(s string) (PoolRef, error) {
|
||||
for i, x := range pl.strings {
|
||||
if s == x {
|
||||
return PoolRef(i), nil
|
||||
}
|
||||
}
|
||||
return 0, fmt.Errorf("PoolRef by name %q does not exist", s)
|
||||
}
|
||||
|
||||
func (pl *Pool) IsSorted() bool { return pl.flags&SortedFlag == SortedFlag }
|
||||
func (pl *Pool) IsUTF8() bool { return pl.flags&UTF8Flag == UTF8Flag }
|
||||
|
||||
func (pl *Pool) UnmarshalBinary(bin []byte) error {
|
||||
if err := (&pl.chunkHeader).UnmarshalBinary(bin); err != nil {
|
||||
return err
|
||||
}
|
||||
if pl.typ != ResStringPool {
|
||||
return fmt.Errorf("have type %s, want %s", pl.typ, ResStringPool)
|
||||
}
|
||||
|
||||
pl.strings = make([]string, btou32(bin[8:]))
|
||||
pl.styles = make([]*Span, btou32(bin[12:]))
|
||||
pl.flags = btou32(bin[16:])
|
||||
|
||||
offstrings := btou32(bin[20:])
|
||||
offstyle := btou32(bin[24:])
|
||||
hdrlen := 28
|
||||
|
||||
if pl.IsUTF8() {
|
||||
for i := range pl.strings {
|
||||
offset := int(offstrings + btou32(bin[hdrlen+i*4:]))
|
||||
|
||||
// if leading bit set for nchars and nbytes,
|
||||
// treat first byte as 7-bit high word and next as low word.
|
||||
nchars := int(bin[offset])
|
||||
offset++
|
||||
if nchars&(1<<7) != 0 {
|
||||
n0 := nchars ^ (1 << 7) // high word
|
||||
n1 := int(bin[offset]) // low word
|
||||
nchars = n0*(1<<8) + n1
|
||||
offset++
|
||||
}
|
||||
|
||||
// TODO(d) At least one case in android.jar (api-10) resource table has only
|
||||
// highbit set, making 7-bit highword zero. The reason for this is currently
|
||||
// unknown but would make tests that unmarshal-marshal to match bytes impossible.
|
||||
// The values noted were high-word: 0 (after highbit unset), low-word: 141
|
||||
// The size may be treated as an int8 triggering the use of two bytes to store size
|
||||
// even though the implementation uses uint8.
|
||||
nbytes := int(bin[offset])
|
||||
offset++
|
||||
if nbytes&(1<<7) != 0 {
|
||||
n0 := nbytes ^ (1 << 7) // high word
|
||||
n1 := int(bin[offset]) // low word
|
||||
nbytes = n0*(1<<8) + n1
|
||||
offset++
|
||||
}
|
||||
|
||||
data := bin[offset : offset+nbytes]
|
||||
if x := uint8(bin[offset+nbytes]); x != 0 {
|
||||
return fmt.Errorf("expected zero terminator, got 0x%02X for nchars=%v nbytes=%v data=%q", x, nchars, nbytes, data)
|
||||
}
|
||||
pl.strings[i] = string(data)
|
||||
}
|
||||
} else {
|
||||
for i := range pl.strings {
|
||||
offset := int(offstrings + btou32(bin[hdrlen+i*4:])) // read index of string
|
||||
|
||||
// if leading bit set for nchars, treat first byte as 7-bit high word and next as low word.
|
||||
nchars := int(btou16(bin[offset:]))
|
||||
offset += 2
|
||||
if nchars&(1<<15) != 0 { // TODO(d) this is untested
|
||||
n0 := nchars ^ (1 << 15) // high word
|
||||
n1 := int(btou16(bin[offset:])) // low word
|
||||
nchars = n0*(1<<16) + n1
|
||||
offset += 2
|
||||
}
|
||||
|
||||
data := make([]uint16, nchars)
|
||||
for i := range data {
|
||||
data[i] = btou16(bin[offset+2*i:])
|
||||
}
|
||||
|
||||
if x := btou16(bin[offset+nchars*2:]); x != 0 {
|
||||
return fmt.Errorf("expected zero terminator, got 0x%04X for nchars=%v data=%q", x, nchars, data)
|
||||
}
|
||||
pl.strings[i] = string(utf16.Decode(data))
|
||||
}
|
||||
}
|
||||
|
||||
// TODO decode styles
|
||||
_ = offstyle
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (pl *Pool) MarshalBinary() ([]byte, error) {
|
||||
if pl.IsUTF8() {
|
||||
return nil, fmt.Errorf("encode utf8 not supported")
|
||||
}
|
||||
|
||||
var (
|
||||
hdrlen = 28
|
||||
// indices of string indices
|
||||
iis = make([]uint32, len(pl.strings))
|
||||
iislen = len(iis) * 4
|
||||
// utf16 encoded strings concatenated together
|
||||
strs []uint16
|
||||
)
|
||||
for i, x := range pl.strings {
|
||||
if len(x)>>16 > 0 {
|
||||
panic(fmt.Errorf("string lengths over 1<<15 not yet supported, got len %d", len(x)))
|
||||
}
|
||||
p := utf16.Encode([]rune(x))
|
||||
if len(p) == 0 {
|
||||
strs = append(strs, 0x0000, 0x0000)
|
||||
} else {
|
||||
strs = append(strs, uint16(len(p))) // string length (implicitly includes zero terminator to follow)
|
||||
strs = append(strs, p...)
|
||||
strs = append(strs, 0) // zero terminated
|
||||
}
|
||||
// indices start at zero
|
||||
if i+1 != len(iis) {
|
||||
iis[i+1] = uint32(len(strs) * 2) // utf16 byte index
|
||||
}
|
||||
}
|
||||
|
||||
// check strings is 4-byte aligned, pad with zeros if not.
|
||||
for x := (len(strs) * 2) % 4; x != 0; x -= 2 {
|
||||
strs = append(strs, 0x0000)
|
||||
}
|
||||
|
||||
strslen := len(strs) * 2
|
||||
|
||||
hdr := chunkHeader{
|
||||
typ: ResStringPool,
|
||||
headerByteSize: 28,
|
||||
byteSize: uint32(28 + iislen + strslen),
|
||||
}
|
||||
|
||||
bin := make([]byte, hdr.byteSize)
|
||||
|
||||
hdrbin, err := hdr.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
copy(bin, hdrbin)
|
||||
|
||||
putu32(bin[8:], uint32(len(pl.strings)))
|
||||
putu32(bin[12:], uint32(len(pl.styles)))
|
||||
putu32(bin[16:], pl.flags)
|
||||
putu32(bin[20:], uint32(hdrlen+iislen))
|
||||
putu32(bin[24:], 0) // index of styles start, is 0 when styles length is 0
|
||||
|
||||
buf := bin[28:]
|
||||
for _, x := range iis {
|
||||
putu32(buf, x)
|
||||
buf = buf[4:]
|
||||
}
|
||||
|
||||
for _, x := range strs {
|
||||
putu16(buf, x)
|
||||
buf = buf[2:]
|
||||
}
|
||||
|
||||
if len(buf) != 0 {
|
||||
panic(fmt.Errorf("failed to fill allocated buffer, %v bytes left over", len(buf)))
|
||||
}
|
||||
|
||||
return bin, nil
|
||||
}
|
||||
|
||||
type Span struct {
|
||||
name PoolRef
|
||||
|
||||
firstChar, lastChar uint32
|
||||
}
|
||||
|
||||
func (spn *Span) UnmarshalBinary(bin []byte) error {
|
||||
const end = 0xFFFFFFFF
|
||||
spn.name = PoolRef(btou32(bin))
|
||||
if spn.name == end {
|
||||
return nil
|
||||
}
|
||||
spn.firstChar = btou32(bin[4:])
|
||||
spn.lastChar = btou32(bin[8:])
|
||||
return nil
|
||||
}
|
||||
|
||||
// Map contains a uint32 slice mapping strings in the string
|
||||
// pool back to resource identifiers. The i'th element of the slice
|
||||
// is also the same i'th element of the string pool.
|
||||
type Map struct {
|
||||
chunkHeader
|
||||
rs []TableRef
|
||||
}
|
||||
|
||||
func (m *Map) UnmarshalBinary(bin []byte) error {
|
||||
(&m.chunkHeader).UnmarshalBinary(bin)
|
||||
buf := bin[m.headerByteSize:m.byteSize]
|
||||
m.rs = make([]TableRef, len(buf)/4)
|
||||
for i := range m.rs {
|
||||
m.rs[i] = TableRef(btou32(buf[i*4:]))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Map) MarshalBinary() ([]byte, error) {
|
||||
m.typ = ResXMLResourceMap
|
||||
m.headerByteSize = 8
|
||||
m.byteSize = uint32(m.headerByteSize) + uint32(len(m.rs)*4)
|
||||
bin := make([]byte, m.byteSize)
|
||||
b, err := m.chunkHeader.MarshalBinary()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
copy(bin, b)
|
||||
for i, r := range m.rs {
|
||||
putu32(bin[8+i*4:], uint32(r))
|
||||
}
|
||||
return bin, nil
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue