mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-20 00:47:28 +01:00
This commit, part of a series, is inspired by pull request PR #168 by Damian Kaczmarek (with AI assistance), with some modifications. There were many stylistic changes but also: - decoder.workbuf_len was fixed to account for all of the partitions, not just the first two (the first partition and the first 'other' partition). The PR's vp8 code, after an update to handle multiple other partitions (which then implied random access to the partitioned source bytes), assumed that enough workbuf was available (which it often is, test/c/std/webp.c tests pass the entire g_work_slice_u8). But strictly speaking, this isn't guaranteed unless workbuf_len reports (after decode_image_config is called) what's needed. - Calculating that workbuf_len (at decode_image_config time) lead to introducing a new base.QUIRK_SOURCE_LENGTH quirk, to pass that contextual information from std/webp to std/vp8. This calculation belongs in std/vp8, not std/webp (or a future std/webm). - Added support (and a test) for the case when the source bytes are streamed and some (but not yet all) of the partition data in args.src can be copied to args.workbuf. Updates PR #168
1210 lines
42 KiB
Go
1210 lines
42 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||
// option. This file may not be copied, modified, or distributed
|
||
// except according to those terms.
|
||
//
|
||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||
|
||
//go:generate go run gen.go
|
||
|
||
// Package builtin lists Wuffs' built-in concepts such as status codes.
|
||
package builtin
|
||
|
||
import (
|
||
"fmt"
|
||
"strings"
|
||
|
||
"github.com/google/wuffs/lang/parse"
|
||
|
||
a "github.com/google/wuffs/lang/ast"
|
||
t "github.com/google/wuffs/lang/token"
|
||
)
|
||
|
||
var FourCCs = [...][2]string{
|
||
{"ABXR", "Android Binary XML (for resources; see AndroidBinXmlParser.java)"},
|
||
{"ABXS", "Android Binary XML (for system_server; see BinaryXmlSerializer.java)"},
|
||
{"BGCL", "Background Color"},
|
||
{"BMP ", "Bitmap"},
|
||
{"BRTL", "Brotli"},
|
||
{"BZ2 ", "Bzip2"},
|
||
{"CBOR", "Concise Binary Object Representation"},
|
||
{"CHRM", "Primary Chromaticities and White Point"},
|
||
{"CSS ", "Cascading Style Sheets"},
|
||
{"EPS ", "Encapsulated PostScript"},
|
||
{"ETC2", "Ericsson Texture Compression 2 (iPACKMAN)"},
|
||
{"EXIF", "Exchangeable Image File Format"},
|
||
{"FLAC", "Free Lossless Audio Codec"},
|
||
{"GAMA", "Gamma Correction"},
|
||
{"GIF ", "Graphics Interchange Format"},
|
||
{"GZ ", "GNU Zip"},
|
||
{"HEIF", "High Efficiency Image File"},
|
||
{"HNSM", "Handsum"},
|
||
{"HTML", "Hypertext Markup Language"},
|
||
{"ICCP", "International Color Consortium Profile"},
|
||
{"ICO ", "Icon"},
|
||
{"ICVG", "Icon Vector Graphics"},
|
||
{"INI ", "Initialization"},
|
||
{"JPEG", "Joint Photographic Experts Group"},
|
||
{"JS ", "JavaScript"},
|
||
{"JSON", "JavaScript Object Notation"},
|
||
{"JWCC", "JSON With Commas and Comments"},
|
||
{"KVP ", "Key-Value Pair"},
|
||
{"KVPK", "Key-Value Pair (Key)"},
|
||
{"KVPV", "Key-Value Pair (Value)"},
|
||
{"LZ4 ", "Lempel–Ziv 4"},
|
||
{"LZIP", "Lzip"},
|
||
{"LZMA", "Lempel–Ziv Markov-chain Algorithm"},
|
||
{"MD ", "Markdown"},
|
||
{"MTIM", "Modification Time"},
|
||
{"MP3 ", "MPEG-1 Audio Layer III"},
|
||
{"NIE ", "Naive Image"},
|
||
{"NPBM", "Netpbm (Portable Anymap)"},
|
||
{"OFS2", "Offset (2-Dimensional)"},
|
||
{"OTF ", "Open Type Format"},
|
||
{"PDF ", "Portable Document Format"},
|
||
{"PHYD", "Physical Dimensions"},
|
||
{"PNG ", "Portable Network Graphics"},
|
||
{"PS ", "PostScript"},
|
||
{"QOI ", "Quite OK Image"},
|
||
{"RAC ", "Random Access Compression"},
|
||
{"RAW ", "Raw"},
|
||
{"RIFF", "Resource Interchange File Format"},
|
||
{"RIGL", "Riegeli Records"},
|
||
{"SNPY", "Snappy"},
|
||
{"SRGB", "Standard Red Green Blue (Rendering Intent)"},
|
||
{"SVG ", "Scalable Vector Graphics"},
|
||
{"TAR ", "Tape Archive"},
|
||
{"TEXT", "Text"},
|
||
{"TGA ", "Truevision Advanced Raster Graphics Adapter"},
|
||
{"TH ", "Thumbhash"},
|
||
{"TIFF", "Tagged Image File Format"},
|
||
{"TOML", "Tom's Obvious Minimal Language"},
|
||
{"WAVE", "Waveform"},
|
||
{"WBMP", "Wireless Bitmap"},
|
||
{"WEBP", "Web Picture"},
|
||
{"WOFF", "Web Open Font Format"},
|
||
{"XML ", "Extensible Markup Language"},
|
||
{"XMP ", "Extensible Metadata Platform"},
|
||
{"XZ ", "Xz"},
|
||
{"ZIP ", "Zip"},
|
||
{"ZLIB", "Zlib"},
|
||
{"ZSTD", "Zstandard"},
|
||
}
|
||
|
||
var Consts = [...]struct {
|
||
Type t.ID
|
||
Value string
|
||
Name string
|
||
}{
|
||
// ----
|
||
|
||
{t.IDU8, "0", "ANIMATION_DISPOSAL__NONE"},
|
||
{t.IDU8, "1", "ANIMATION_DISPOSAL__RESTORE_BACKGROUND"},
|
||
{t.IDU8, "2", "ANIMATION_DISPOSAL__RESTORE_PREVIOUS"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "1", "MORE_INFORMATION__FLAVOR__IO_REDIRECT"},
|
||
{t.IDU32, "2", "MORE_INFORMATION__FLAVOR__IO_SEEK"},
|
||
{t.IDU32, "3", "MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH"},
|
||
{t.IDU32, "4", "MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM"},
|
||
{t.IDU32, "5", "MORE_INFORMATION__FLAVOR__METADATA_PARSED"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x02000008", "PIXEL_FORMAT__A"},
|
||
|
||
{t.IDU32, "0x20000008", "PIXEL_FORMAT__Y"},
|
||
{t.IDU32, "0x2000000B", "PIXEL_FORMAT__Y_16LE"},
|
||
{t.IDU32, "0x2010000B", "PIXEL_FORMAT__Y_16BE"},
|
||
{t.IDU32, "0x21000088", "PIXEL_FORMAT__YA_NONPREMUL"},
|
||
{t.IDU32, "0x22000088", "PIXEL_FORMAT__YA_PREMUL"},
|
||
{t.IDU32, "0x30008888", "PIXEL_FORMAT__YXXX"},
|
||
|
||
{t.IDU32, "0x40020888", "PIXEL_FORMAT__YCBCR"},
|
||
{t.IDU32, "0x41038888", "PIXEL_FORMAT__YCBCRA_NONPREMUL"},
|
||
{t.IDU32, "0x50038888", "PIXEL_FORMAT__YCBCRK"},
|
||
|
||
{t.IDU32, "0x60020888", "PIXEL_FORMAT__YCOCG"},
|
||
{t.IDU32, "0x61038888", "PIXEL_FORMAT__YCOCGA_NONPREMUL"},
|
||
{t.IDU32, "0x70038888", "PIXEL_FORMAT__YCOCGK"},
|
||
|
||
{t.IDU32, "0x81040008", "PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL"},
|
||
{t.IDU32, "0x82040008", "PIXEL_FORMAT__INDEXED__BGRA_PREMUL"},
|
||
{t.IDU32, "0x83040008", "PIXEL_FORMAT__INDEXED__BGRA_BINARY"},
|
||
|
||
{t.IDU32, "0x80000565", "PIXEL_FORMAT__BGR_565"},
|
||
{t.IDU32, "0x80000888", "PIXEL_FORMAT__BGR"},
|
||
{t.IDU32, "0x81008888", "PIXEL_FORMAT__BGRA_NONPREMUL"},
|
||
{t.IDU32, "0x8100BBBB", "PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE"},
|
||
{t.IDU32, "0x82008888", "PIXEL_FORMAT__BGRA_PREMUL"},
|
||
{t.IDU32, "0x8200BBBB", "PIXEL_FORMAT__BGRA_PREMUL_4X16LE"},
|
||
{t.IDU32, "0x83008888", "PIXEL_FORMAT__BGRA_BINARY"},
|
||
{t.IDU32, "0x90008888", "PIXEL_FORMAT__BGRX"},
|
||
|
||
{t.IDU32, "0xA0000888", "PIXEL_FORMAT__RGB"},
|
||
{t.IDU32, "0xA1008888", "PIXEL_FORMAT__RGBA_NONPREMUL"},
|
||
{t.IDU32, "0xA100BBBB", "PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE"},
|
||
{t.IDU32, "0xA2008888", "PIXEL_FORMAT__RGBA_PREMUL"},
|
||
{t.IDU32, "0xA200BBBB", "PIXEL_FORMAT__RGBA_PREMUL_4X16LE"},
|
||
{t.IDU32, "0xA3008888", "PIXEL_FORMAT__RGBA_BINARY"},
|
||
{t.IDU32, "0xB0008888", "PIXEL_FORMAT__RGBX"},
|
||
|
||
{t.IDU32, "0xC0020888", "PIXEL_FORMAT__CMY"},
|
||
{t.IDU32, "0xD0038888", "PIXEL_FORMAT__CMYK"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "1", "QUIRK_IGNORE_CHECKSUM"},
|
||
{t.IDU32, "2", "QUIRK_QUALITY"},
|
||
{t.IDU32, "3", "QUIRK_SOURCE_LENGTH"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "46", "TOKEN__VALUE_EXTENSION__NUM_BITS"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0", "TOKEN__VBC__FILLER"},
|
||
{t.IDU32, "1", "TOKEN__VBC__STRUCTURE"},
|
||
{t.IDU32, "2", "TOKEN__VBC__STRING"},
|
||
{t.IDU32, "3", "TOKEN__VBC__UNICODE_CODE_POINT"},
|
||
{t.IDU32, "4", "TOKEN__VBC__LITERAL"},
|
||
{t.IDU32, "5", "TOKEN__VBC__NUMBER"},
|
||
{t.IDU32, "6", "TOKEN__VBC__INLINE_INTEGER_SIGNED"},
|
||
{t.IDU32, "7", "TOKEN__VBC__INLINE_INTEGER_UNSIGNED"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x00001", "TOKEN__VBD__FILLER__PUNCTUATION"},
|
||
{t.IDU32, "0x00002", "TOKEN__VBD__FILLER__COMMENT_BLOCK"},
|
||
{t.IDU32, "0x00004", "TOKEN__VBD__FILLER__COMMENT_LINE"},
|
||
{t.IDU32, "0x00006", "TOKEN__VBD__FILLER__COMMENT_ANY"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x00001", "TOKEN__VBD__STRUCTURE__PUSH"},
|
||
{t.IDU32, "0x00002", "TOKEN__VBD__STRUCTURE__POP"},
|
||
{t.IDU32, "0x00010", "TOKEN__VBD__STRUCTURE__FROM_NONE"},
|
||
{t.IDU32, "0x00020", "TOKEN__VBD__STRUCTURE__FROM_LIST"},
|
||
{t.IDU32, "0x00040", "TOKEN__VBD__STRUCTURE__FROM_DICT"},
|
||
{t.IDU32, "0x01000", "TOKEN__VBD__STRUCTURE__TO_NONE"},
|
||
{t.IDU32, "0x02000", "TOKEN__VBD__STRUCTURE__TO_LIST"},
|
||
{t.IDU32, "0x04000", "TOKEN__VBD__STRUCTURE__TO_DICT"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x00001", "TOKEN__VBD__STRING__DEFINITELY_UTF_8"},
|
||
{t.IDU32, "0x00002", "TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8"},
|
||
{t.IDU32, "0x00004", "TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8"},
|
||
{t.IDU32, "0x00010", "TOKEN__VBD__STRING__DEFINITELY_ASCII"},
|
||
{t.IDU32, "0x00020", "TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII"},
|
||
{t.IDU32, "0x00040", "TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII"},
|
||
|
||
{t.IDU32, "0x00100", "TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP"},
|
||
{t.IDU32, "0x00200", "TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY"},
|
||
{t.IDU32, "0x00400", "TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL"},
|
||
{t.IDU32, "0x00800", "TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X"},
|
||
{t.IDU32, "0x01000", "TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD"},
|
||
{t.IDU32, "0x02000", "TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL"},
|
||
{t.IDU32, "0x04000", "TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85"},
|
||
{t.IDU32, "0x08000", "TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX"},
|
||
{t.IDU32, "0x10000", "TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x00001", "TOKEN__VBD__LITERAL__UNDEFINED"},
|
||
{t.IDU32, "0x00002", "TOKEN__VBD__LITERAL__NULL"},
|
||
{t.IDU32, "0x00004", "TOKEN__VBD__LITERAL__FALSE"},
|
||
{t.IDU32, "0x00008", "TOKEN__VBD__LITERAL__TRUE"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0x00001", "TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT"},
|
||
{t.IDU32, "0x00002", "TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED"},
|
||
{t.IDU32, "0x00004", "TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED"},
|
||
|
||
{t.IDU32, "0x00010", "TOKEN__VBD__NUMBER__CONTENT_NEG_INF"},
|
||
{t.IDU32, "0x00020", "TOKEN__VBD__NUMBER__CONTENT_POS_INF"},
|
||
{t.IDU32, "0x00040", "TOKEN__VBD__NUMBER__CONTENT_NEG_NAN"},
|
||
{t.IDU32, "0x00080", "TOKEN__VBD__NUMBER__CONTENT_POS_NAN"},
|
||
|
||
{t.IDU32, "0x00100", "TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN"},
|
||
{t.IDU32, "0x00200", "TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN"},
|
||
{t.IDU32, "0x00400", "TOKEN__VBD__NUMBER__FORMAT_TEXT"},
|
||
|
||
{t.IDU32, "0x01000", "TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE"},
|
||
|
||
// ----
|
||
|
||
{t.IDU32, "0xFFFD", "UNICODE__REPLACEMENT_CHARACTER"},
|
||
}
|
||
|
||
var Statuses = [...]string{
|
||
// Notes.
|
||
`"@I/O redirect"`,
|
||
`"@end of data"`,
|
||
`"@metadata reported"`,
|
||
|
||
// Suspensions.
|
||
`"$even more information"`,
|
||
`"$mispositioned read"`,
|
||
`"$mispositioned write"`,
|
||
`"$short read"`,
|
||
`"$short workbuf"`,
|
||
`"$short write"`,
|
||
|
||
// Errors.
|
||
`"#bad I/O position"`,
|
||
`"#bad argument (length too short)"`,
|
||
`"#bad argument"`,
|
||
`"#bad call sequence"`,
|
||
`"#bad data"`,
|
||
`"#bad receiver"`,
|
||
`"#bad restart"`,
|
||
`"#bad sizeof receiver"`,
|
||
`"#bad vtable"`,
|
||
`"#bad workbuf length"`,
|
||
`"#bad wuffs version"`,
|
||
`"#cannot return a suspension"`,
|
||
`"#disabled by WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST"`,
|
||
`"#disabled by previous error"`,
|
||
`"#initialize falsely claimed already zeroed"`,
|
||
`"#initialize not called"`,
|
||
`"#insufficient history"`,
|
||
`"#interleaved coroutine calls"`,
|
||
`"#no more information"`,
|
||
`"#not enough data"`,
|
||
`"#out of bounds"`,
|
||
`"#unsupported image dimension"`,
|
||
`"#unsupported method"`,
|
||
`"#unsupported option"`,
|
||
`"#unsupported pixel swizzler option"`,
|
||
`"#too much data"`,
|
||
}
|
||
|
||
// TODO: a collection of forbidden variable names like and, or, not, as, false,
|
||
// true, in, out, this, u8, u16, etc?
|
||
|
||
var Types = []string{
|
||
// TODO: i8, i16, i32, i64.
|
||
"u8",
|
||
"u16",
|
||
"u32",
|
||
"u64",
|
||
|
||
"bitvec256",
|
||
|
||
"optional_u63",
|
||
|
||
"empty_struct",
|
||
"bool",
|
||
"utility",
|
||
|
||
"range_ii_u32",
|
||
"range_ie_u32",
|
||
"range_ii_u64",
|
||
"range_ie_u64",
|
||
"rect_ie_u32",
|
||
"rect_ii_u32",
|
||
|
||
"more_information",
|
||
|
||
"status",
|
||
|
||
"io_reader",
|
||
"io_writer",
|
||
"token_reader",
|
||
"token_writer",
|
||
|
||
"frame_config",
|
||
"image_config",
|
||
"pixel_blend",
|
||
"pixel_buffer",
|
||
"pixel_config",
|
||
"pixel_format",
|
||
"pixel_swizzler",
|
||
|
||
"decode_frame_options",
|
||
|
||
// ----
|
||
|
||
"arm_crc32_utility",
|
||
"arm_crc32_u32",
|
||
|
||
"arm_neon_utility",
|
||
"arm_neon_u8x8",
|
||
"arm_neon_u16x4",
|
||
"arm_neon_u32x2",
|
||
"arm_neon_u64x1",
|
||
"arm_neon_u8x16",
|
||
"arm_neon_u16x8",
|
||
"arm_neon_u32x4",
|
||
"arm_neon_u64x2",
|
||
|
||
"x86_sse42_utility",
|
||
"x86_m128i",
|
||
|
||
"x86_avx2_utility",
|
||
"x86_m256i",
|
||
}
|
||
|
||
var Funcs = [][]string{
|
||
funcsOther[:], // Manually authored methods.
|
||
funcsARMNeon[:], // Automatically generated methods (intrinsics).
|
||
}
|
||
|
||
var funcsOther = [...]string{
|
||
"u8.high_bits(n: u32[..= 7]) u8",
|
||
"u8.low_bits(n: u32[..= 7]) u8",
|
||
"u8.max(no_less_than: u8) u8",
|
||
"u8.min(no_more_than: u8) u8",
|
||
|
||
"u16.high_bits(n: u32[..= 15]) u16",
|
||
"u16.low_bits(n: u32[..= 15]) u16",
|
||
"u16.max(no_less_than: u16) u16",
|
||
"u16.min(no_more_than: u16) u16",
|
||
|
||
"u32.high_bits(n: u32[..= 31]) u32",
|
||
"u32.low_bits(n: u32[..= 31]) u32",
|
||
"u32.max(no_less_than: u32) u32",
|
||
"u32.min(no_more_than: u32) u32",
|
||
|
||
"u64.high_bits(n: u32[..= 63]) u64",
|
||
"u64.low_bits(n: u32[..= 63]) u64",
|
||
"u64.max(no_less_than: u64) u64",
|
||
"u64.min(no_more_than: u64) u64",
|
||
|
||
"bitvec256.get_u64(i: u32[..=3]) u64",
|
||
|
||
// ---- utility
|
||
|
||
"utility.cpu_arch_is_32_bit() bool",
|
||
"utility.empty_io_reader() io_reader",
|
||
"utility.empty_io_writer() io_writer",
|
||
"utility.empty_range_ii_u32() range_ii_u32",
|
||
"utility.empty_range_ie_u32() range_ie_u32",
|
||
"utility.empty_range_ii_u64() range_ii_u64",
|
||
"utility.empty_range_ie_u64() range_ie_u64",
|
||
"utility.empty_rect_ii_u32() rect_ii_u32",
|
||
"utility.empty_rect_ie_u32() rect_ie_u32",
|
||
"utility.empty_slice_u8() slice u8",
|
||
"utility.i64_divide(a: u64, b: u64[1 ..=]) u64",
|
||
"utility.make_bitvec256(e00: u64, e01: u64, e02: u64, e03: u64) bitvec256",
|
||
"utility.make_optional_u63(has_value: bool, value: u64[..= 0x7FFF_FFFF_FFFF_FFFF]) optional_u63",
|
||
"utility.make_pixel_format(repr: u32) pixel_format",
|
||
"utility.make_range_ii_u32(min_incl: u32, max_incl: u32) range_ii_u32",
|
||
"utility.make_range_ie_u32(min_incl: u32, max_excl: u32) range_ie_u32",
|
||
"utility.make_range_ii_u64(min_incl: u64, max_incl: u64) range_ii_u64",
|
||
"utility.make_range_ie_u64(min_incl: u64, max_excl: u64) range_ie_u64",
|
||
"utility.make_rect_ii_u32(" +
|
||
"min_incl_x: u32, min_incl_y: u32, max_incl_x: u32, max_incl_y: u32) rect_ii_u32",
|
||
"utility.make_rect_ie_u32(" +
|
||
"min_incl_x: u32, min_incl_y: u32, max_excl_x: u32, max_excl_y: u32) rect_ie_u32",
|
||
"utility.sign_extend_convert_u8_u32(a: u8) u32",
|
||
"utility.sign_extend_convert_u8_u64(a: u8) u64",
|
||
"utility.sign_extend_convert_u16_u32(a: u16) u32",
|
||
"utility.sign_extend_convert_u16_u64(a: u16) u64",
|
||
"utility.sign_extend_convert_u32_u64(a: u32) u64",
|
||
"utility.sign_extend_rshift_u32(a: u32, n: u32[..= 31]) u32",
|
||
"utility.sign_extend_rshift_u64(a: u64, n: u32[..= 63]) u64",
|
||
|
||
// ---- ranges
|
||
|
||
"range_ie_u32.get_min_incl() u32",
|
||
"range_ie_u32.get_max_excl() u32",
|
||
"range_ie_u32.intersect(r: range_ie_u32) range_ie_u32",
|
||
"range_ie_u32.unite(r: range_ie_u32) range_ie_u32",
|
||
|
||
"range_ii_u32.get_min_incl() u32",
|
||
"range_ii_u32.get_max_incl() u32",
|
||
"range_ii_u32.intersect(r: range_ii_u32) range_ii_u32",
|
||
"range_ii_u32.unite(r: range_ii_u32) range_ii_u32",
|
||
|
||
"range_ie_u64.get_min_incl() u64",
|
||
"range_ie_u64.get_max_excl() u64",
|
||
"range_ie_u64.intersect(r: range_ie_u64) range_ie_u64",
|
||
"range_ie_u64.unite(r: range_ie_u64) range_ie_u64",
|
||
|
||
"range_ii_u64.get_min_incl() u64",
|
||
"range_ii_u64.get_max_incl() u64",
|
||
"range_ii_u64.intersect(r: range_ii_u64) range_ii_u64",
|
||
"range_ii_u64.unite(r: range_ii_u64) range_ii_u64",
|
||
|
||
// ---- more_information
|
||
|
||
"more_information.set!(flavor: u32, w: u32, x: u64, y: u64, z: u64)",
|
||
|
||
// ---- status
|
||
|
||
// TODO: should we add is_complete?
|
||
"status.is_error() bool",
|
||
"status.is_note() bool",
|
||
"status.is_ok() bool",
|
||
"status.is_suspension() bool",
|
||
|
||
// ---- io_reader
|
||
|
||
"io_reader.can_undo_byte() bool",
|
||
"io_reader.peek_undo_byte() u8",
|
||
"io_reader.undo_byte!()",
|
||
|
||
"io_reader.read_u8?() u8",
|
||
|
||
"io_reader.read_u8_as_u16?() u16[..= 0xFF]",
|
||
"io_reader.read_u16be?() u16",
|
||
"io_reader.read_u16le?() u16",
|
||
|
||
"io_reader.read_u8_as_u32?() u32[..= 0xFF]",
|
||
"io_reader.read_u16be_as_u32?() u32[..= 0xFFFF]",
|
||
"io_reader.read_u16le_as_u32?() u32[..= 0xFFFF]",
|
||
"io_reader.read_u24be_as_u32?() u32[..= 0xFF_FFFF]",
|
||
"io_reader.read_u24le_as_u32?() u32[..= 0xFF_FFFF]",
|
||
"io_reader.read_u32be?() u32",
|
||
"io_reader.read_u32le?() u32",
|
||
|
||
"io_reader.read_u8_as_u64?() u64[..= 0xFF]",
|
||
"io_reader.read_u16be_as_u64?() u64[..= 0xFFFF]",
|
||
"io_reader.read_u16le_as_u64?() u64[..= 0xFFFF]",
|
||
"io_reader.read_u24be_as_u64?() u64[..= 0xFF_FFFF]",
|
||
"io_reader.read_u24le_as_u64?() u64[..= 0xFF_FFFF]",
|
||
"io_reader.read_u32be_as_u64?() u64[..= 0xFFFF_FFFF]",
|
||
"io_reader.read_u32le_as_u64?() u64[..= 0xFFFF_FFFF]",
|
||
"io_reader.read_u40be_as_u64?() u64[..= 0xFF_FFFF_FFFF]",
|
||
"io_reader.read_u40le_as_u64?() u64[..= 0xFF_FFFF_FFFF]",
|
||
"io_reader.read_u48be_as_u64?() u64[..= 0xFFFF_FFFF_FFFF]",
|
||
"io_reader.read_u48le_as_u64?() u64[..= 0xFFFF_FFFF_FFFF]",
|
||
"io_reader.read_u56be_as_u64?() u64[..= 0xFF_FFFF_FFFF_FFFF]",
|
||
"io_reader.read_u56le_as_u64?() u64[..= 0xFF_FFFF_FFFF_FFFF]",
|
||
"io_reader.read_u64be?() u64",
|
||
"io_reader.read_u64le?() u64",
|
||
|
||
// TODO: these should have an explicit pre-condition "length() >= N". For
|
||
// now, that's implicitly checked (i.e. hard coded).
|
||
//
|
||
// io_reader has peek_etc methods and skip_u32_fast, not read_etc_fast,
|
||
// because we sometimes advance the pointer by less than what's read. See
|
||
// https://fgiesen.wordpress.com/2018/02/20/reading-bits-in-far-too-many-ways-part-2/
|
||
|
||
"io_reader.peek_u8() u8",
|
||
|
||
"io_reader.peek_u8_as_u16() u16[..= 0xFF]",
|
||
"io_reader.peek_u16be() u16",
|
||
"io_reader.peek_u16le() u16",
|
||
|
||
"io_reader.peek_u8_as_u32() u32[..= 0xFF]",
|
||
"io_reader.peek_u16be_as_u32() u32[..= 0xFFFF]",
|
||
"io_reader.peek_u16le_as_u32() u32[..= 0xFFFF]",
|
||
"io_reader.peek_u24be_as_u32() u32[..= 0xFF_FFFF]",
|
||
"io_reader.peek_u24le_as_u32() u32[..= 0xFF_FFFF]",
|
||
"io_reader.peek_u32be() u32",
|
||
"io_reader.peek_u32le() u32",
|
||
|
||
"io_reader.peek_u8_as_u64() u64[..= 0xFF]",
|
||
"io_reader.peek_u16be_as_u64() u64[..= 0xFFFF]",
|
||
"io_reader.peek_u16le_as_u64() u64[..= 0xFFFF]",
|
||
"io_reader.peek_u24be_as_u64() u64[..= 0xFF_FFFF]",
|
||
"io_reader.peek_u24le_as_u64() u64[..= 0xFF_FFFF]",
|
||
"io_reader.peek_u32be_as_u64() u64[..= 0xFFFF_FFFF]",
|
||
"io_reader.peek_u32le_as_u64() u64[..= 0xFFFF_FFFF]",
|
||
"io_reader.peek_u40be_as_u64() u64[..= 0xFF_FFFF_FFFF]",
|
||
"io_reader.peek_u40le_as_u64() u64[..= 0xFF_FFFF_FFFF]",
|
||
"io_reader.peek_u48be_as_u64() u64[..= 0xFFFF_FFFF_FFFF]",
|
||
"io_reader.peek_u48le_as_u64() u64[..= 0xFFFF_FFFF_FFFF]",
|
||
"io_reader.peek_u56be_as_u64() u64[..= 0xFF_FFFF_FFFF_FFFF]",
|
||
"io_reader.peek_u56le_as_u64() u64[..= 0xFF_FFFF_FFFF_FFFF]",
|
||
"io_reader.peek_u64be() u64",
|
||
"io_reader.peek_u64le() u64",
|
||
|
||
// As an implementation restriction, we require that offset has a constant
|
||
// value. The (0x1_0000 - sizeof(uxx)) limit is arbitrary, but high enough
|
||
// in practice.
|
||
"io_reader.peek_u8_at(offset: u32[..= 0xFFFF]) u8",
|
||
"io_reader.peek_u64le_at(offset: u32[..= 0xFFF8]) u64",
|
||
|
||
"io_reader.count_since(mark: u64) u64",
|
||
"io_reader.is_closed() bool",
|
||
"io_reader.length() u64",
|
||
"io_reader.mark() u64",
|
||
"io_reader.match7(a: u64) u32[..= 2]",
|
||
"io_reader.position() u64",
|
||
"io_reader.since(mark: u64) roslice u8",
|
||
"io_reader.valid_utf_8_length(up_to: u64) u64",
|
||
|
||
"io_reader.limited_copy_u32_to_slice!(up_to: u32, s: slice u8) u32",
|
||
|
||
"io_reader.skip?(n: u64)",
|
||
"io_reader.skip_u32?(n: u32)",
|
||
|
||
// TODO: this should have explicit pre-conditions "actual <= worst_case"
|
||
// and "worst_case <= length()". For now, that's all implicitly checked
|
||
// (i.e. hard coded).
|
||
"io_reader.skip_u32_fast!(actual: u32, worst_case: u32)",
|
||
|
||
// ---- io_writer
|
||
|
||
"io_writer.can_undo_byte() bool",
|
||
"io_writer.peek_undo_byte() u8",
|
||
"io_writer.undo_byte!()",
|
||
|
||
"io_writer.write_u8?(a: u8)",
|
||
"io_writer.write_u16be?(a: u16)",
|
||
"io_writer.write_u16le?(a: u16)",
|
||
"io_writer.write_u24be?(a: u32[..= 0xFF_FFFF])",
|
||
"io_writer.write_u24le?(a: u32[..= 0xFF_FFFF])",
|
||
"io_writer.write_u32be?(a: u32)",
|
||
"io_writer.write_u32le?(a: u32)",
|
||
"io_writer.write_u40be?(a: u64[..= 0xFF_FFFF_FFFF])",
|
||
"io_writer.write_u40le?(a: u64[..= 0xFF_FFFF_FFFF])",
|
||
"io_writer.write_u48be?(a: u64[..= 0xFFFF_FFFF_FFFF])",
|
||
"io_writer.write_u48le?(a: u64[..= 0xFFFF_FFFF_FFFF])",
|
||
"io_writer.write_u56be?(a: u64[..= 0xFF_FFFF_FFFF_FFFF])",
|
||
"io_writer.write_u56le?(a: u64[..= 0xFF_FFFF_FFFF_FFFF])",
|
||
"io_writer.write_u64be?(a: u64)",
|
||
"io_writer.write_u64le?(a: u64)",
|
||
|
||
// TODO: these should have an explicit pre-condition "length() >= N". For
|
||
// now, that's implicitly checked (i.e. hard coded).
|
||
//
|
||
// io_writer has write_etc_fast methods, not poke_etc and skip_u32_fast,
|
||
// because skip_u32_fast could leave uninitialized bytes in the io_buffer.
|
||
"io_writer.write_u8_fast!(a: u8)",
|
||
"io_writer.write_u16be_fast!(a: u16)",
|
||
"io_writer.write_u16le_fast!(a: u16)",
|
||
"io_writer.write_u24be_fast!(a: u32[..= 0xFF_FFFF])",
|
||
"io_writer.write_u24le_fast!(a: u32[..= 0xFF_FFFF])",
|
||
"io_writer.write_u32be_fast!(a: u32)",
|
||
"io_writer.write_u32le_fast!(a: u32)",
|
||
"io_writer.write_u40be_fast!(a: u64[..= 0xFF_FFFF_FFFF])",
|
||
"io_writer.write_u40le_fast!(a: u64[..= 0xFF_FFFF_FFFF])",
|
||
"io_writer.write_u48be_fast!(a: u64[..= 0xFFFF_FFFF_FFFF])",
|
||
"io_writer.write_u48le_fast!(a: u64[..= 0xFFFF_FFFF_FFFF])",
|
||
"io_writer.write_u56be_fast!(a: u64[..= 0xFF_FFFF_FFFF_FFFF])",
|
||
"io_writer.write_u56le_fast!(a: u64[..= 0xFF_FFFF_FFFF_FFFF])",
|
||
"io_writer.write_u64be_fast!(a: u64)",
|
||
"io_writer.write_u64le_fast!(a: u64)",
|
||
|
||
"io_writer.count_since(mark: u64) u64",
|
||
"io_writer.history_length() u64",
|
||
"io_writer.history_position() u64",
|
||
"io_writer.length() u64",
|
||
"io_writer.mark() u64",
|
||
"io_writer.position() u64",
|
||
"io_writer.since(mark: u64) slice u8",
|
||
|
||
"io_writer.copy_from_slice!(s: roslice u8) u64",
|
||
"io_writer.limited_copy_u32_from_history!(up_to: u32, distance: u32) u32",
|
||
"io_writer.limited_copy_u32_from_reader!(up_to: u32, r: io_reader) u32",
|
||
"io_writer.limited_copy_u32_from_slice!(up_to: u32, s: roslice u8) u32",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - up_to <= this.length()
|
||
// - distance >= 1
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_fast!(up_to: u32, distance: u32) u32",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - up_to <= this.length()
|
||
// - distance >= 1
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_fast_return_cusp!(up_to: u32, distance: u32) u32[..= 0xFFFF]",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - (up_to + 8) <= this.length()
|
||
// - distance >= 8
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_8_byte_chunks_fast!(up_to: u32, distance: u32) u32",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - (up_to + 8) <= this.length()
|
||
// - distance >= 8
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_8_byte_chunks_fast_return_cusp!(up_to: u32, distance: u32) u32[..= 0xFFFF]",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - (up_to + 8) <= this.length()
|
||
// - distance == 1
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_8_byte_chunks_distance_1_fast!(up_to: u32, distance: u32) u32",
|
||
|
||
// TODO: this should have explicit pre-conditions:
|
||
// - up_to >= 1
|
||
// - (up_to + 8) <= this.length()
|
||
// - distance == 1
|
||
// - distance <= this.history_length()
|
||
// For now, that's all implicitly checked (i.e. hard coded).
|
||
"io_writer.limited_copy_u32_from_history_8_byte_chunks_distance_1_fast_return_cusp!(up_to: u32, distance: u32) u32[..= 0xFFFF]",
|
||
|
||
// ---- token_writer
|
||
|
||
"token_writer.write_simple_token_fast!(" +
|
||
"value_major: u32[..= 0x1F_FFFF], value_minor: u32[..= 0x1FF_FFFF]," +
|
||
"continued: u32[..= 0x1], length: u32[..= 0xFFFF])",
|
||
"token_writer.write_extended_token_fast!(" +
|
||
"value_extension: u64[..= 0x3FFF_FFFF_FFFF]," +
|
||
"continued: u32[..= 0x1], length: u32[..= 0xFFFF])",
|
||
|
||
"token_writer.length() u64",
|
||
|
||
// ---- frame_config
|
||
|
||
"frame_config.blend() u8",
|
||
"frame_config.disposal() u8",
|
||
"frame_config.duration() u64[..= 0x7FFF_FFFF_FFFF_FFFF]",
|
||
"frame_config.index() u64",
|
||
"frame_config.io_position() u64",
|
||
|
||
"frame_config.set!(bounds: rect_ie_u32, duration: u64[..= 0x7FFF_FFFF_FFFF_FFFF]," +
|
||
"index: u64, io_position: u64, disposal: u8, opaque_within_bounds: bool," +
|
||
"overwrite_instead_of_blend: bool, background_color: u32)",
|
||
|
||
// ---- image_config
|
||
|
||
"image_config.set!(pixfmt: u32, pixsub: u32, width: u32[..= 0xFF_FFFF], height: u32[..= 0xFF_FFFF]," +
|
||
"first_frame_io_position: u64, first_frame_is_opaque: bool)",
|
||
|
||
// ---- pixel_buffer
|
||
|
||
"pixel_buffer.palette() slice u8",
|
||
"pixel_buffer.palette_or_else(fallback: slice u8) slice u8",
|
||
"pixel_buffer.pixel_format() pixel_format",
|
||
"pixel_buffer.plane(p: u32[..= 3]) table u8",
|
||
|
||
// ---- pixel_format
|
||
|
||
"pixel_format.bits_per_pixel() u32[..= 256]",
|
||
"pixel_format.default_background_color() u32",
|
||
|
||
// ---- pixel_swizzler
|
||
|
||
"pixel_swizzler.prepare!(" +
|
||
"dst_pixfmt: pixel_format, dst_palette: slice u8," +
|
||
"src_pixfmt: pixel_format, src_palette: roslice u8, blend: pixel_blend) status",
|
||
|
||
"pixel_swizzler.limited_swizzle_u32_interleaved_from_reader!(" +
|
||
"up_to_num_pixels: u32, dst: slice u8, dst_palette: slice u8, src: io_reader) u64",
|
||
"pixel_swizzler.swizzle_interleaved_from_reader!(" +
|
||
"dst: slice u8, dst_palette: slice u8, src: io_reader) u64",
|
||
"pixel_swizzler.swizzle_interleaved_from_slice!(" +
|
||
"dst: slice u8, dst_palette: slice u8, src: roslice u8) u64",
|
||
"pixel_swizzler.swizzle_interleaved_transparent_black!(" +
|
||
"dst: slice u8, dst_palette: slice u8, num_pixels: u64) u64",
|
||
"pixel_swizzler.swizzle_ycck!(" +
|
||
"dst: ptr pixel_buffer," +
|
||
"dst_palette: slice u8," +
|
||
"x_min_incl: u32[..= 0xFFFF]," +
|
||
"x_max_excl: u32[..= 0xFFFF]," +
|
||
"y_min_incl: u32[..= 0xFFFF]," +
|
||
"y_max_excl: u32[..= 0xFFFF]," +
|
||
"src0: slice u8," +
|
||
"src1: slice u8," +
|
||
"src2: slice u8," +
|
||
"src3: slice u8," +
|
||
"width0: u32[..= 0x4_0000]," +
|
||
"width1: u32[..= 0x4_0000]," +
|
||
"width2: u32[..= 0x4_0000]," +
|
||
"width3: u32[..= 0x4_0000]," +
|
||
"height0: u32[..= 0x4_0000]," +
|
||
"height1: u32[..= 0x4_0000]," +
|
||
"height2: u32[..= 0x4_0000]," +
|
||
"height3: u32[..= 0x4_0000]," +
|
||
"stride0: u32," +
|
||
"stride1: u32," +
|
||
"stride2: u32," +
|
||
"stride3: u32," +
|
||
"h0: u8[..= 4]," +
|
||
"h1: u8[..= 4]," +
|
||
"h2: u8[..= 4]," +
|
||
"h3: u8[..= 4]," +
|
||
"v0: u8[..= 4]," +
|
||
"v1: u8[..= 4]," +
|
||
"v2: u8[..= 4]," +
|
||
"v3: u8[..= 4]," +
|
||
"is_rgb_or_cmyk: bool," +
|
||
"triangle_filter_for_2to1: bool," +
|
||
"scratch_buffer_2k: slice u8) status",
|
||
|
||
// ---- arm_crc32_utility
|
||
|
||
"arm_crc32_utility.make_u32(a: u32) arm_crc32_u32",
|
||
|
||
// ---- arm_crc32_u32
|
||
|
||
"arm_crc32_u32.crc32b(b: u8) arm_crc32_u32",
|
||
"arm_crc32_u32.crc32h(b: u16) arm_crc32_u32",
|
||
"arm_crc32_u32.crc32w(b: u32) arm_crc32_u32",
|
||
"arm_crc32_u32.crc32d(b: u64) arm_crc32_u32",
|
||
"arm_crc32_u32.value() u32",
|
||
|
||
// ---- arm_neon_utility
|
||
|
||
"arm_neon_utility.make_u8x8_multiple(" +
|
||
"a00: u8, a01: u8, a02: u8, a03: u8," +
|
||
"a04: u8, a05: u8, a06: u8, a07: u8) arm_neon_u8x8",
|
||
"arm_neon_utility.make_u16x4_multiple(" +
|
||
"a00: u16, a01: u16, a02: u16, a03: u16) arm_neon_u16x4",
|
||
"arm_neon_utility.make_u32x2_multiple(" +
|
||
"a00: u32, a01: u32) arm_neon_u32x2",
|
||
"arm_neon_utility.make_u64x1_multiple(" +
|
||
"a00: u64) arm_neon_u64x1",
|
||
|
||
"arm_neon_utility.make_u8x16_multiple(" +
|
||
"a00: u8, a01: u8, a02: u8, a03: u8," +
|
||
"a04: u8, a05: u8, a06: u8, a07: u8," +
|
||
"a08: u8, a09: u8, a10: u8, a11: u8," +
|
||
"a12: u8, a13: u8, a14: u8, a15: u8) arm_neon_u8x16",
|
||
"arm_neon_utility.make_u16x8_multiple(" +
|
||
"a00: u16, a01: u16, a02: u16, a03: u16," +
|
||
"a04: u16, a05: u16, a06: u16, a07: u16) arm_neon_u16x8",
|
||
"arm_neon_utility.make_u32x4_multiple(" +
|
||
"a00: u32, a01: u32, a02: u32, a03: u32) arm_neon_u32x4",
|
||
"arm_neon_utility.make_u64x2_multiple(" +
|
||
"a00: u64, a01: u64) arm_neon_u64x2",
|
||
|
||
"arm_neon_utility.make_u8x8_repeat(a: u8) arm_neon_u8x8",
|
||
"arm_neon_utility.make_u16x4_repeat(a: u16) arm_neon_u16x4",
|
||
"arm_neon_utility.make_u32x2_repeat(a: u32) arm_neon_u32x2",
|
||
"arm_neon_utility.make_u64x1_repeat(a: u64) arm_neon_u64x1",
|
||
|
||
"arm_neon_utility.make_u8x16_repeat(a: u8) arm_neon_u8x16",
|
||
"arm_neon_utility.make_u16x8_repeat(a: u16) arm_neon_u16x8",
|
||
"arm_neon_utility.make_u32x4_repeat(a: u32) arm_neon_u32x4",
|
||
"arm_neon_utility.make_u64x2_repeat(a: u64) arm_neon_u64x2",
|
||
|
||
"arm_neon_utility.make_u8x8_slice64(a: roslice base.u8) arm_neon_u8x8",
|
||
"arm_neon_utility.make_u8x16_slice128(a: roslice base.u8) arm_neon_u8x16",
|
||
|
||
// ---- arm_neon_uAxB.as_uCxD
|
||
|
||
"arm_neon_u8x8.as_u16x4() arm_neon_u16x4",
|
||
"arm_neon_u8x8.as_u32x2() arm_neon_u32x2",
|
||
"arm_neon_u8x8.as_u64x1() arm_neon_u64x1",
|
||
|
||
"arm_neon_u16x4.as_u8x8() arm_neon_u8x8",
|
||
"arm_neon_u32x2.as_u8x8() arm_neon_u8x8",
|
||
"arm_neon_u64x1.as_u8x8() arm_neon_u8x8",
|
||
|
||
"arm_neon_u16x8.as_u16x8() arm_neon_u16x8",
|
||
"arm_neon_u16x8.as_u32x4() arm_neon_u32x4",
|
||
"arm_neon_u16x8.as_u64x2() arm_neon_u64x2",
|
||
|
||
"arm_neon_u16x8.as_u8x16() arm_neon_u8x16",
|
||
"arm_neon_u32x4.as_u8x16() arm_neon_u8x16",
|
||
"arm_neon_u64x2.as_u8x16() arm_neon_u8x16",
|
||
|
||
// ---- x86_sse42_utility
|
||
|
||
"x86_sse42_utility.make_m128i_multiple_u8(" +
|
||
"a00: u8, a01: u8, a02: u8, a03: u8," +
|
||
"a04: u8, a05: u8, a06: u8, a07: u8," +
|
||
"a08: u8, a09: u8, a10: u8, a11: u8," +
|
||
"a12: u8, a13: u8, a14: u8, a15: u8) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_multiple_u16(" +
|
||
"a00: u16, a01: u16, a02: u16, a03: u16," +
|
||
"a04: u16, a05: u16, a06: u16, a07: u16) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_multiple_u32(" +
|
||
"a00: u32, a01: u32, a02: u32, a03: u32) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_multiple_u64(" +
|
||
"a00: u64, a01: u64) x86_m128i",
|
||
|
||
"x86_sse42_utility.make_m128i_repeat_u8(a: u8) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_repeat_u16(a: u16) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_repeat_u32(a: u32) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_repeat_u64(a: u64) x86_m128i",
|
||
|
||
"x86_sse42_utility.make_m128i_single_u32(a: u32) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_single_u64(a: u64) x86_m128i",
|
||
|
||
"x86_sse42_utility.make_m128i_slice128(a: roslice base.u8) x86_m128i",
|
||
"x86_sse42_utility.make_m128i_slice_u16lex8(a: roslice base.u16) x86_m128i",
|
||
|
||
"x86_sse42_utility.make_m128i_zeroes() x86_m128i",
|
||
|
||
"x86_sse42_utility.make_u64_slice_u16lex4(a: roslice base.u16) u64",
|
||
|
||
// ---- x86_m128i
|
||
|
||
"x86_m128i.store_slice64!(a: slice base.u8)",
|
||
"x86_m128i.store_slice128!(a: slice base.u8)",
|
||
|
||
"x86_m128i.truncate_u32() u32",
|
||
"x86_m128i.truncate_u64() u64",
|
||
|
||
// TODO: generate these methods automatically?
|
||
|
||
"x86_m128i._mm_abs_epi16() x86_m128i",
|
||
"x86_m128i._mm_add_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_add_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_add_epi64(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_add_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_and_si128(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_avg_epu16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_avg_epu8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_blend_epi16(b: x86_m128i, imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_blendv_epi8(b: x86_m128i, mask: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_clmulepi64_si128(b: x86_m128i, imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_cmpeq_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_cmpeq_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_cmpeq_epi64(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_cmpeq_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_extract_epi16(imm8: u32) u16",
|
||
"x86_m128i._mm_extract_epi32(imm8: u32) u32",
|
||
"x86_m128i._mm_extract_epi64(imm8: u32) u64",
|
||
"x86_m128i._mm_extract_epi8(imm8: u32) u8",
|
||
"x86_m128i._mm_madd_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_maddubs_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epu16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epu32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_max_epu8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epu16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epu32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_min_epu8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_mullo_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_or_si128(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_packs_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_packus_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_sad_epu8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_shuffle_epi32(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_shuffle_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_slli_epi16(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_slli_epi32(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_slli_epi64(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_slli_si128(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_srli_epi16(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_srli_epi32(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_srli_epi64(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_srli_si128(imm8: u32) x86_m128i",
|
||
"x86_m128i._mm_sub_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_sub_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_sub_epi64(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_sub_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpackhi_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpackhi_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpackhi_epi64(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpackhi_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpacklo_epi16(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpacklo_epi32(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpacklo_epi64(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_unpacklo_epi8(b: x86_m128i) x86_m128i",
|
||
"x86_m128i._mm_xor_si128(b: x86_m128i) x86_m128i",
|
||
|
||
// ---- x86_avx2_utility
|
||
|
||
"x86_avx2_utility.make_m256i_multiple_u8(" +
|
||
"a00: u8, a01: u8, a02: u8, a03: u8," +
|
||
"a04: u8, a05: u8, a06: u8, a07: u8," +
|
||
"a08: u8, a09: u8, a10: u8, a11: u8," +
|
||
"a12: u8, a13: u8, a14: u8, a15: u8," +
|
||
"a16: u8, a17: u8, a18: u8, a19: u8," +
|
||
"a20: u8, a21: u8, a22: u8, a23: u8," +
|
||
"a24: u8, a25: u8, a26: u8, a27: u8," +
|
||
"a28: u8, a29: u8, a30: u8, a31: u8) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_multiple_u16(" +
|
||
"a00: u16, a01: u16, a02: u16, a03: u16," +
|
||
"a04: u16, a05: u16, a06: u16, a07: u16," +
|
||
"a08: u16, a09: u16, a10: u16, a11: u16," +
|
||
"a12: u16, a13: u16, a14: u16, a15: u16) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_multiple_u32(" +
|
||
"a00: u32, a01: u32, a02: u32, a03: u32," +
|
||
"a04: u32, a05: u32, a06: u32, a07: u32) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_multiple_u64(" +
|
||
"a00: u64, a01: u64, a02: u64, a03: u64) x86_m256i",
|
||
|
||
"x86_avx2_utility.make_m256i_repeat_u8(a: u8) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_repeat_u16(a: u16) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_repeat_u32(a: u32) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_repeat_u64(a: u64) x86_m256i",
|
||
|
||
"x86_avx2_utility.make_m256i_slice256(a: roslice base.u8) x86_m256i",
|
||
"x86_avx2_utility.make_m256i_slice_u16lex16(a: roslice base.u16) x86_m256i",
|
||
|
||
"x86_avx2_utility.make_m256i_zeroes() x86_m256i",
|
||
|
||
"x86_avx2_utility.make_u64_slice_u16lex4(a: roslice base.u16) u64",
|
||
|
||
// ---- x86_m256i
|
||
|
||
"x86_m256i.store_slice64!(a: slice base.u8)",
|
||
"x86_m256i.store_slice128!(a: slice base.u8)",
|
||
"x86_m256i.store_slice256!(a: slice base.u8)",
|
||
|
||
// TODO: generate these methods automatically?
|
||
|
||
"x86_m256i._mm256_add_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_add_epi32(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_add_epi64(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_add_epi8(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_and_si256(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_castsi256_si128() x86_m128i",
|
||
"x86_m256i._mm256_extract_epi64(index: u32) u64",
|
||
"x86_m256i._mm256_extracti128_si256(imm8: u32) x86_m128i",
|
||
"x86_m256i._mm256_inserti128_si256(b: x86_m128i, imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_madd_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_maddubs_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_mullo_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_or_si256(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_packs_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_packs_epi32(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_permute2x128_si256(b: x86_m256i, imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_permute4x64_epi64(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_sad_epu8(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_shuffle_epi32(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_sign_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_slli_epi16(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_slli_epi32(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_slli_epi64(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_slli_si256(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srai_epi16(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srai_epi32(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srai_epi64(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srai_si256(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srli_epi16(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srli_epi32(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srli_epi64(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_srli_si256(imm8: u32) x86_m256i",
|
||
"x86_m256i._mm256_sub_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_sub_epi32(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_sub_epi64(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_sub_epi8(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_testz_si256(b: x86_m256i) u32",
|
||
"x86_m256i._mm256_unpackhi_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpackhi_epi32(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpackhi_epi64(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpackhi_epi8(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpacklo_epi16(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpacklo_epi32(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpacklo_epi64(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_unpacklo_epi8(b: x86_m256i) x86_m256i",
|
||
"x86_m256i._mm256_xor_si256(b: x86_m256i) x86_m256i",
|
||
}
|
||
|
||
var Interfaces = []string{
|
||
"hasher_u32",
|
||
"hasher_u64",
|
||
"hasher_bitvec256",
|
||
"image_decoder",
|
||
"io_transformer",
|
||
"token_decoder",
|
||
}
|
||
|
||
var InterfacesMap = map[string]bool{
|
||
"hasher_u32": true,
|
||
"hasher_u64": true,
|
||
"hasher_bitvec256": true,
|
||
"image_decoder": true,
|
||
"io_transformer": true,
|
||
"token_decoder": true,
|
||
}
|
||
|
||
var InterfaceFuncs = []string{
|
||
// ---- hasher_u32
|
||
|
||
"hasher_u32.checksum_u32() u32",
|
||
"hasher_u32.get_quirk(key: u32) u64",
|
||
"hasher_u32.set_quirk!(key: u32, value: u64) status",
|
||
"hasher_u32.update!(x: roslice u8)",
|
||
"hasher_u32.update_u32!(x: roslice u8) u32",
|
||
|
||
// ---- hasher_u64
|
||
|
||
"hasher_u64.checksum_u64() u64",
|
||
"hasher_u64.get_quirk(key: u32) u64",
|
||
"hasher_u64.set_quirk!(key: u32, value: u64) status",
|
||
"hasher_u64.update!(x: roslice u8)",
|
||
"hasher_u64.update_u64!(x: roslice u8) u64",
|
||
|
||
// ---- hasher_bitvec256
|
||
|
||
"hasher_bitvec256.checksum_bitvec256() bitvec256",
|
||
"hasher_bitvec256.get_quirk(key: u32) u64",
|
||
"hasher_bitvec256.set_quirk!(key: u32, value: u64) status",
|
||
"hasher_bitvec256.update!(x: roslice u8)",
|
||
"hasher_bitvec256.update_bitvec256!(x: roslice u8) bitvec256",
|
||
|
||
// ---- image_decoder
|
||
|
||
"image_decoder.decode_frame?(" +
|
||
"dst: ptr pixel_buffer, src: io_reader, blend: pixel_blend," +
|
||
"workbuf: slice u8, opts: nptr decode_frame_options)",
|
||
"image_decoder.decode_frame_config?(dst: nptr frame_config, src: io_reader)",
|
||
"image_decoder.decode_image_config?(dst: nptr image_config, src: io_reader)",
|
||
"image_decoder.frame_dirty_rect() rect_ie_u32",
|
||
"image_decoder.get_quirk(key: u32) u64",
|
||
"image_decoder.num_animation_loops() u32",
|
||
"image_decoder.num_decoded_frame_configs() u64",
|
||
"image_decoder.num_decoded_frames() u64",
|
||
"image_decoder.restart_frame!(index: u64, io_position: u64) status",
|
||
"image_decoder.set_quirk!(key: u32, value: u64) status",
|
||
"image_decoder.set_report_metadata!(fourcc: u32, report: bool)",
|
||
"image_decoder.tell_me_more?(dst: io_writer, minfo: nptr more_information, src: io_reader)",
|
||
"image_decoder.workbuf_len() range_ii_u64",
|
||
|
||
// ---- io_transformer
|
||
|
||
// TODO: "io_transformer.add_history!(hist: slice u8)"? Should it take a workbuf arg?
|
||
"io_transformer.dst_history_retain_length() optional_u63",
|
||
"io_transformer.get_quirk(key: u32) u64",
|
||
"io_transformer.set_quirk!(key: u32, value: u64) status",
|
||
"io_transformer.transform_io?(dst: io_writer, src: io_reader, workbuf: slice u8)",
|
||
"io_transformer.workbuf_len() range_ii_u64",
|
||
|
||
// ---- token_decoder
|
||
|
||
"token_decoder.decode_tokens?(dst: token_writer, src: io_reader, workbuf: slice u8)",
|
||
"token_decoder.get_quirk(key: u32) u64",
|
||
"token_decoder.set_quirk!(key: u32, value: u64) status",
|
||
"token_decoder.workbuf_len() range_ii_u64",
|
||
}
|
||
|
||
// The "T1" and "T2" types here are placeholders for generic "slice T" or
|
||
// "table T" types. After tokenizing (but before parsing) these XxxFunc strings
|
||
// (e.g. in the lang/check package), replace "T1" and "T2" with "†" or "‡"
|
||
// daggers, to avoid collision with a user-defined "T1" or "T2" type.
|
||
//
|
||
// Ditto for "R1" / "ρ", for a read-only flavor of "T1" / "†".
|
||
|
||
const (
|
||
genericOldName1 = t.IDT1
|
||
genericOldName2 = t.IDT2
|
||
genericOldNameRo1 = t.IDR1
|
||
genericNewName1 = t.IDDagger1
|
||
genericNewName2 = t.IDDagger2
|
||
genericNewNameRo1 = t.IDRho1
|
||
)
|
||
|
||
var SliceFuncs = []string{
|
||
"GENERIC T1.copy_from_slice!(s: R1) u64",
|
||
"GENERIC T1.length() u64",
|
||
"GENERIC T1.prefix(up_to: u64) T1",
|
||
"GENERIC T1.uintptr_low_12_bits() u32[..= 4095]",
|
||
"GENERIC T1.suffix(up_to: u64) T1",
|
||
|
||
// The bulk_etc methods are further restricted to those T1 slices whose
|
||
// elements are bulk-numeric types: numerics (e.g. base.u32), arrays of
|
||
// numerics, arrays of arrays of numerics, etc.
|
||
"GENERIC T1.bulk_load_host_endian!(src: slice u8)",
|
||
"GENERIC T1.bulk_memset!(byte_value: u8)",
|
||
"GENERIC T1.bulk_save_host_endian!(dst: slice u8)",
|
||
}
|
||
|
||
var SliceU8Funcs = []string{
|
||
"GENERIC T1.peek_u8() u8",
|
||
"GENERIC T1.peek_u16be() u16",
|
||
"GENERIC T1.peek_u16le() u16",
|
||
"GENERIC T1.peek_u24be_as_u32() u32",
|
||
"GENERIC T1.peek_u24le_as_u32() u32",
|
||
"GENERIC T1.peek_u32be() u32",
|
||
"GENERIC T1.peek_u32le() u32",
|
||
"GENERIC T1.peek_u40be_as_u64() u64",
|
||
"GENERIC T1.peek_u40le_as_u64() u64",
|
||
"GENERIC T1.peek_u48be_as_u64() u64",
|
||
"GENERIC T1.peek_u48le_as_u64() u64",
|
||
"GENERIC T1.peek_u56be_as_u64() u64",
|
||
"GENERIC T1.peek_u56le_as_u64() u64",
|
||
"GENERIC T1.peek_u64be() u64",
|
||
"GENERIC T1.peek_u64le() u64",
|
||
|
||
"GENERIC T1.poke_u8!(a: u8)",
|
||
"GENERIC T1.poke_u16be!(a: u16)",
|
||
"GENERIC T1.poke_u16le!(a: u16)",
|
||
"GENERIC T1.poke_u24be!(a: u32)",
|
||
"GENERIC T1.poke_u24le!(a: u32)",
|
||
"GENERIC T1.poke_u32be!(a: u32)",
|
||
"GENERIC T1.poke_u32le!(a: u32)",
|
||
"GENERIC T1.poke_u40be!(a: u64)",
|
||
"GENERIC T1.poke_u40le!(a: u64)",
|
||
"GENERIC T1.poke_u48be!(a: u64)",
|
||
"GENERIC T1.poke_u48le!(a: u64)",
|
||
"GENERIC T1.poke_u56be!(a: u64)",
|
||
"GENERIC T1.poke_u56le!(a: u64)",
|
||
"GENERIC T1.poke_u64be!(a: u64)",
|
||
"GENERIC T1.poke_u64le!(a: u64)",
|
||
}
|
||
|
||
var TableFuncs = []string{
|
||
"GENERIC T2.height() u64",
|
||
"GENERIC T2.stride() u64",
|
||
"GENERIC T2.width() u64",
|
||
|
||
"GENERIC T2.row_u32(y: u32) T1",
|
||
"GENERIC T2.subtable(" +
|
||
"min_incl_x: u64, min_incl_y: u64, max_incl_x: u64, max_incl_y: u64) T2",
|
||
}
|
||
|
||
func ParseFuncs(tm *t.Map, ss []string, callback func(*a.Func) error) error {
|
||
if len(ss) == 0 {
|
||
return nil
|
||
}
|
||
const GENERIC = "GENERIC "
|
||
generic := strings.HasPrefix(ss[0], GENERIC)
|
||
|
||
buf := []byte(nil)
|
||
for _, s := range ss {
|
||
if generic && (len(s) >= len(GENERIC)) {
|
||
s = s[len(GENERIC):]
|
||
}
|
||
buf = append(buf, "pub func "...)
|
||
buf = append(buf, s...)
|
||
buf = append(buf, "{}\n"...)
|
||
}
|
||
|
||
const filename = "builtin.wuffs"
|
||
tokens, _, err := t.Tokenize(tm, filename, buf)
|
||
if err != nil {
|
||
return fmt.Errorf("could not tokenize built-in funcs: %v", err)
|
||
}
|
||
|
||
if generic {
|
||
for i := range tokens {
|
||
tok := &tokens[i]
|
||
if id := tok.ID; id == genericOldName1 {
|
||
tok.ID = genericNewName1
|
||
} else if id == genericOldName2 {
|
||
tok.ID = genericNewName2
|
||
} else if id == genericOldNameRo1 {
|
||
tok.ID = genericNewNameRo1
|
||
}
|
||
}
|
||
}
|
||
|
||
file, err := parse.Parse(tm, filename, tokens, &parse.Options{
|
||
AllowBuiltInNames: true,
|
||
})
|
||
if err != nil {
|
||
return fmt.Errorf("could not parse built-in funcs: %v", err)
|
||
}
|
||
|
||
for _, tld := range file.TopLevelDecls() {
|
||
if tld.Kind() != a.KFunc {
|
||
continue
|
||
}
|
||
f := tld.AsFunc()
|
||
f.AsNode().AsRaw().SetPackage(tm, t.IDBase)
|
||
if callback != nil {
|
||
if err := callback(f); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|