···937937938938Flags passed to the `strip` command applied to the files in the directories listed in `stripDebugList`. Defaults to `-S` (i.e. `--strip-debug`).
939939940940+##### `stripExclude` {#var-stdenv-stripExclude}
941941+942942+A list of filenames or path patterns to avoid stripping. A file is excluded if its name _or_ path (from the derivation root) matches.
943943+944944+This example prevents all `*.rlib` files from being stripped:
945945+946946+```nix
947947+stdenv.mkDerivation {
948948+ # ...
949949+ stripExclude = [ "*.rlib" ]
950950+}
951951+```
952952+953953+This example prevents files within certain paths from being stripped:
954954+955955+```nix
956956+stdenv.mkDerivation {
957957+ # ...
958958+ stripExclude = [ "lib/modules/*/build/* ]
959959+}
960960+```
961961+940962##### `dontPatchELF` {#var-stdenv-dontPatchELF}
941963942964If set, the `patchelf` command is not used to remove unnecessary `RPATH` entries. Only applies to Linux.
···6969 # try to detect share/doc/${shareDocName}
7070 # Note: sadly, $configureScript detection comes later in configurePhase,
7171 # and reordering would cause more trouble than worth.
7272- if [ -z "$shareDocName" ]; then
7373- local confScript="$configureScript"
7272+ if [ -z "${shareDocName:-}" ]; then
7373+ local confScript="${configureScript:-}"
7474 if [ -z "$confScript" ] && [ -x ./configure ]; then
7575 confScript=./configure
7676 fi
+1-1
pkgs/build-support/setup-hooks/patch-shebangs.sh
···7575 read -r oldInterpreterLine < "$f"
7676 read -r oldPath arg0 args <<< "${oldInterpreterLine:2}"
77777878- if [[ -z "$pathName" ]]; then
7878+ if [[ -z "${pathName:-}" ]]; then
7979 if [[ -n $strictDeps && $f == "$NIX_STORE"* ]]; then
8080 pathName=HOST_PATH
8181 else
···2121 while IFS= read -r -d $'\0' i; do
2222 if ! isELF "$i"; then continue; fi
23232424+ [ -z "${READELF:-}" ] && echo "_separateDebugInfo: '\$READELF' variable is empty, skipping." 1>&2 && break
2525+ [ -z "${OBJCOPY:-}" ] && echo "_separateDebugInfo: '\$OBJCOPY' variable is empty, skipping." 1>&2 && break
2626+2427 # Extract the Build ID. FIXME: there's probably a cleaner way.
2528 local id="$($READELF -n "$i" | sed 's/.*Build ID: \([0-9a-f]*\).*/\1/; t; d')"
2629 if [ "${#id}" != 40 ]; then
+9-1
pkgs/build-support/setup-hooks/strip.sh
···4949 local ranlibCmd="$2"
5050 local paths="$3"
5151 local stripFlags="$4"
5252+ local excludeFlags=()
5253 local pathsNew=
53545455 [ -z "$cmd" ] && echo "stripDirs: Strip command is empty" 1>&2 && exit 1
5556 [ -z "$ranlibCmd" ] && echo "stripDirs: Ranlib command is empty" 1>&2 && exit 1
5757+5858+ local pattern
5959+ if [ -n "${stripExclude:-}" ]; then
6060+ for pattern in "${stripExclude[@]}"; do
6161+ excludeFlags+=(-a '!' '(' -name "$pattern" -o -wholename "$prefix/$pattern" ')' )
6262+ done
6363+ fi
56645765 local p
5866 for p in ${paths}; do
···6775 local striperr
6876 striperr="$(mktemp --tmpdir="$TMPDIR" 'striperr.XXXXXX')"
6977 # Do not strip lib/debug. This is a directory used by setup-hooks/separate-debug-info.sh.
7070- find $paths -type f -a '!' -path "$prefix/lib/debug/*" -print0 |
7878+ find $paths -type f "${excludeFlags[@]}" -a '!' -path "$prefix/lib/debug/*" -print0 |
7179 # Make sure we process files under symlinks only once. Otherwise
7280 # 'strip` can corrupt files when writes to them in parallel:
7381 # https://github.com/NixOS/nixpkgs/issues/246147#issuecomment-1657072039
···4545 ];
46464747 patches = [
4848- ./purity.patch
4848+ ../../common/clang/5-8-purity.patch
4949 # make clang -xhip use $PATH to find executables
5050 ./HIP-use-PATH-7.patch
5151 # Backport for the `--unwindlib=[libgcc|compiler-rt]` flag, which is
···4545 ];
46464747 patches = [
4848- ./purity.patch
4848+ ../../common/clang/5-8-purity.patch
4949 ./xpc.patch
5050 # Backport for -static-pie, which the latter touches, and which is nice in
5151 # its own right.
···11+From 4de93ac70c3292fc944e4587101a52a29f8b0c9c Mon Sep 17 00:00:00 2001
22+From: Vincent Rabaud <vrabaud@google.com>
33+Date: Thu, 7 Sep 2023 21:16:03 +0200
44+Subject: [PATCH] Fix OOB write in BuildHuffmanTable.
55+66+First, BuildHuffmanTable is called to check if the data is valid.
77+If it is and the table is not big enough, more memory is allocated.
88+99+This will make sure that valid (but unoptimized because of unbalanced
1010+codes) streams are still decodable.
1111+1212+Bug: chromium:1479274
1313+Change-Id: I31c36dbf3aa78d35ecf38706b50464fd3d375741
1414+(cherry picked from commit 902bc9190331343b2017211debcec8d2ab87e17a)
1515+---
1616+ src/dec/vp8l_dec.c | 46 ++++++++++---------
1717+ src/dec/vp8li_dec.h | 2 +-
1818+ src/utils/huffman_utils.c | 97 +++++++++++++++++++++++++++++++--------
1919+ src/utils/huffman_utils.h | 27 +++++++++--
2020+ 4 files changed, 129 insertions(+), 43 deletions(-)
2121+2222+diff --git a/src/dec/vp8l_dec.c b/src/dec/vp8l_dec.c
2323+index c0ea0181..7995313f 100644
2424+--- a/src/dec/vp8l_dec.c
2525++++ b/src/dec/vp8l_dec.c
2626+@@ -253,11 +253,11 @@ static int ReadHuffmanCodeLengths(
2727+ int symbol;
2828+ int max_symbol;
2929+ int prev_code_len = DEFAULT_CODE_LENGTH;
3030+- HuffmanCode table[1 << LENGTHS_TABLE_BITS];
3131++ HuffmanTables tables;
3232+3333+- if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS,
3434+- code_length_code_lengths,
3535+- NUM_CODE_LENGTH_CODES)) {
3636++ if (!VP8LHuffmanTablesAllocate(1 << LENGTHS_TABLE_BITS, &tables) ||
3737++ !VP8LBuildHuffmanTable(&tables, LENGTHS_TABLE_BITS,
3838++ code_length_code_lengths, NUM_CODE_LENGTH_CODES)) {
3939+ goto End;
4040+ }
4141+4242+@@ -277,7 +277,7 @@ static int ReadHuffmanCodeLengths(
4343+ int code_len;
4444+ if (max_symbol-- == 0) break;
4545+ VP8LFillBitWindow(br);
4646+- p = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
4747++ p = &tables.curr_segment->start[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK];
4848+ VP8LSetBitPos(br, br->bit_pos_ + p->bits);
4949+ code_len = p->value;
5050+ if (code_len < kCodeLengthLiterals) {
5151+@@ -300,6 +300,7 @@ static int ReadHuffmanCodeLengths(
5252+ ok = 1;
5353+5454+ End:
5555++ VP8LHuffmanTablesDeallocate(&tables);
5656+ if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR;
5757+ return ok;
5858+ }
5959+@@ -307,7 +308,8 @@ static int ReadHuffmanCodeLengths(
6060+ // 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman
6161+ // tree.
6262+ static int ReadHuffmanCode(int alphabet_size, VP8LDecoder* const dec,
6363+- int* const code_lengths, HuffmanCode* const table) {
6464++ int* const code_lengths,
6565++ HuffmanTables* const table) {
6666+ int ok = 0;
6767+ int size = 0;
6868+ VP8LBitReader* const br = &dec->br_;
6969+@@ -362,8 +364,7 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
7070+ VP8LMetadata* const hdr = &dec->hdr_;
7171+ uint32_t* huffman_image = NULL;
7272+ HTreeGroup* htree_groups = NULL;
7373+- HuffmanCode* huffman_tables = NULL;
7474+- HuffmanCode* huffman_table = NULL;
7575++ HuffmanTables* huffman_tables = &hdr->huffman_tables_;
7676+ int num_htree_groups = 1;
7777+ int num_htree_groups_max = 1;
7878+ int max_alphabet_size = 0;
7979+@@ -372,6 +373,10 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
8080+ int* mapping = NULL;
8181+ int ok = 0;
8282+8383++ // Check the table has been 0 initialized (through InitMetadata).
8484++ assert(huffman_tables->root.start == NULL);
8585++ assert(huffman_tables->curr_segment == NULL);
8686++
8787+ if (allow_recursion && VP8LReadBits(br, 1)) {
8888+ // use meta Huffman codes.
8989+ const int huffman_precision = VP8LReadBits(br, 3) + 2;
9090+@@ -434,16 +439,15 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
9191+9292+ code_lengths = (int*)WebPSafeCalloc((uint64_t)max_alphabet_size,
9393+ sizeof(*code_lengths));
9494+- huffman_tables = (HuffmanCode*)WebPSafeMalloc(num_htree_groups * table_size,
9595+- sizeof(*huffman_tables));
9696+ htree_groups = VP8LHtreeGroupsNew(num_htree_groups);
9797+9898+- if (htree_groups == NULL || code_lengths == NULL || huffman_tables == NULL) {
9999++ if (htree_groups == NULL || code_lengths == NULL ||
100100++ !VP8LHuffmanTablesAllocate(num_htree_groups * table_size,
101101++ huffman_tables)) {
102102+ dec->status_ = VP8_STATUS_OUT_OF_MEMORY;
103103+ goto Error;
104104+ }
105105+106106+- huffman_table = huffman_tables;
107107+ for (i = 0; i < num_htree_groups_max; ++i) {
108108+ // If the index "i" is unused in the Huffman image, just make sure the
109109+ // coefficients are valid but do not store them.
110110+@@ -468,19 +472,20 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
111111+ int max_bits = 0;
112112+ for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) {
113113+ int alphabet_size = kAlphabetSize[j];
114114+- htrees[j] = huffman_table;
115115+ if (j == 0 && color_cache_bits > 0) {
116116+ alphabet_size += (1 << color_cache_bits);
117117+ }
118118+- size = ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_table);
119119++ size =
120120++ ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_tables);
121121++ htrees[j] = huffman_tables->curr_segment->curr_table;
122122+ if (size == 0) {
123123+ goto Error;
124124+ }
125125+ if (is_trivial_literal && kLiteralMap[j] == 1) {
126126+- is_trivial_literal = (huffman_table->bits == 0);
127127++ is_trivial_literal = (htrees[j]->bits == 0);
128128+ }
129129+- total_size += huffman_table->bits;
130130+- huffman_table += size;
131131++ total_size += htrees[j]->bits;
132132++ huffman_tables->curr_segment->curr_table += size;
133133+ if (j <= ALPHA) {
134134+ int local_max_bits = code_lengths[0];
135135+ int k;
136136+@@ -515,14 +520,13 @@ static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize,
137137+ hdr->huffman_image_ = huffman_image;
138138+ hdr->num_htree_groups_ = num_htree_groups;
139139+ hdr->htree_groups_ = htree_groups;
140140+- hdr->huffman_tables_ = huffman_tables;
141141+142142+ Error:
143143+ WebPSafeFree(code_lengths);
144144+ WebPSafeFree(mapping);
145145+ if (!ok) {
146146+ WebPSafeFree(huffman_image);
147147+- WebPSafeFree(huffman_tables);
148148++ VP8LHuffmanTablesDeallocate(huffman_tables);
149149+ VP8LHtreeGroupsFree(htree_groups);
150150+ }
151151+ return ok;
152152+@@ -1358,7 +1362,7 @@ static void ClearMetadata(VP8LMetadata* const hdr) {
153153+ assert(hdr != NULL);
154154+155155+ WebPSafeFree(hdr->huffman_image_);
156156+- WebPSafeFree(hdr->huffman_tables_);
157157++ VP8LHuffmanTablesDeallocate(&hdr->huffman_tables_);
158158+ VP8LHtreeGroupsFree(hdr->htree_groups_);
159159+ VP8LColorCacheClear(&hdr->color_cache_);
160160+ VP8LColorCacheClear(&hdr->saved_color_cache_);
161161+@@ -1673,7 +1677,7 @@ int VP8LDecodeImage(VP8LDecoder* const dec) {
162162+163163+ if (dec == NULL) return 0;
164164+165165+- assert(dec->hdr_.huffman_tables_ != NULL);
166166++ assert(dec->hdr_.huffman_tables_.root.start != NULL);
167167+ assert(dec->hdr_.htree_groups_ != NULL);
168168+ assert(dec->hdr_.num_htree_groups_ > 0);
169169+170170+diff --git a/src/dec/vp8li_dec.h b/src/dec/vp8li_dec.h
171171+index 72b2e861..32540a4b 100644
172172+--- a/src/dec/vp8li_dec.h
173173++++ b/src/dec/vp8li_dec.h
174174+@@ -51,7 +51,7 @@ typedef struct {
175175+ uint32_t* huffman_image_;
176176+ int num_htree_groups_;
177177+ HTreeGroup* htree_groups_;
178178+- HuffmanCode* huffman_tables_;
179179++ HuffmanTables huffman_tables_;
180180+ } VP8LMetadata;
181181+182182+ typedef struct VP8LDecoder VP8LDecoder;
183183+diff --git a/src/utils/huffman_utils.c b/src/utils/huffman_utils.c
184184+index 90c2fbf7..cf73abd4 100644
185185+--- a/src/utils/huffman_utils.c
186186++++ b/src/utils/huffman_utils.c
187187+@@ -177,21 +177,24 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
188188+ if (num_open < 0) {
189189+ return 0;
190190+ }
191191+- if (root_table == NULL) continue;
192192+ for (; count[len] > 0; --count[len]) {
193193+ HuffmanCode code;
194194+ if ((key & mask) != low) {
195195+- table += table_size;
196196++ if (root_table != NULL) table += table_size;
197197+ table_bits = NextTableBitSize(count, len, root_bits);
198198+ table_size = 1 << table_bits;
199199+ total_size += table_size;
200200+ low = key & mask;
201201+- root_table[low].bits = (uint8_t)(table_bits + root_bits);
202202+- root_table[low].value = (uint16_t)((table - root_table) - low);
203203++ if (root_table != NULL) {
204204++ root_table[low].bits = (uint8_t)(table_bits + root_bits);
205205++ root_table[low].value = (uint16_t)((table - root_table) - low);
206206++ }
207207++ }
208208++ if (root_table != NULL) {
209209++ code.bits = (uint8_t)(len - root_bits);
210210++ code.value = (uint16_t)sorted[symbol++];
211211++ ReplicateValue(&table[key >> root_bits], step, table_size, code);
212212+ }
213213+- code.bits = (uint8_t)(len - root_bits);
214214+- code.value = (uint16_t)sorted[symbol++];
215215+- ReplicateValue(&table[key >> root_bits], step, table_size, code);
216216+ key = GetNextKey(key, len);
217217+ }
218218+ }
219219+@@ -211,25 +214,83 @@ static int BuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
220220+ ((1 << MAX_CACHE_BITS) + NUM_LITERAL_CODES + NUM_LENGTH_CODES)
221221+ // Cut-off value for switching between heap and stack allocation.
222222+ #define SORTED_SIZE_CUTOFF 512
223223+-int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
224224++int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
225225+ const int code_lengths[], int code_lengths_size) {
226226+- int total_size;
227227++ const int total_size =
228228++ BuildHuffmanTable(NULL, root_bits, code_lengths, code_lengths_size, NULL);
229229+ assert(code_lengths_size <= MAX_CODE_LENGTHS_SIZE);
230230+- if (root_table == NULL) {
231231+- total_size = BuildHuffmanTable(NULL, root_bits,
232232+- code_lengths, code_lengths_size, NULL);
233233+- } else if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
234234++ if (total_size == 0 || root_table == NULL) return total_size;
235235++
236236++ if (root_table->curr_segment->curr_table + total_size >=
237237++ root_table->curr_segment->start + root_table->curr_segment->size) {
238238++ // If 'root_table' does not have enough memory, allocate a new segment.
239239++ // The available part of root_table->curr_segment is left unused because we
240240++ // need a contiguous buffer.
241241++ const int segment_size = root_table->curr_segment->size;
242242++ struct HuffmanTablesSegment* next =
243243++ (HuffmanTablesSegment*)WebPSafeMalloc(1, sizeof(*next));
244244++ if (next == NULL) return 0;
245245++ // Fill the new segment.
246246++ // We need at least 'total_size' but if that value is small, it is better to
247247++ // allocate a big chunk to prevent more allocations later. 'segment_size' is
248248++ // therefore chosen (any other arbitrary value could be chosen).
249249++ next->size = total_size > segment_size ? total_size : segment_size;
250250++ next->start =
251251++ (HuffmanCode*)WebPSafeMalloc(next->size, sizeof(*next->start));
252252++ if (next->start == NULL) {
253253++ WebPSafeFree(next);
254254++ return 0;
255255++ }
256256++ next->curr_table = next->start;
257257++ next->next = NULL;
258258++ // Point to the new segment.
259259++ root_table->curr_segment->next = next;
260260++ root_table->curr_segment = next;
261261++ }
262262++ if (code_lengths_size <= SORTED_SIZE_CUTOFF) {
263263+ // use local stack-allocated array.
264264+ uint16_t sorted[SORTED_SIZE_CUTOFF];
265265+- total_size = BuildHuffmanTable(root_table, root_bits,
266266+- code_lengths, code_lengths_size, sorted);
267267+- } else { // rare case. Use heap allocation.
268268++ BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits,
269269++ code_lengths, code_lengths_size, sorted);
270270++ } else { // rare case. Use heap allocation.
271271+ uint16_t* const sorted =
272272+ (uint16_t*)WebPSafeMalloc(code_lengths_size, sizeof(*sorted));
273273+ if (sorted == NULL) return 0;
274274+- total_size = BuildHuffmanTable(root_table, root_bits,
275275+- code_lengths, code_lengths_size, sorted);
276276++ BuildHuffmanTable(root_table->curr_segment->curr_table, root_bits,
277277++ code_lengths, code_lengths_size, sorted);
278278+ WebPSafeFree(sorted);
279279+ }
280280+ return total_size;
281281+ }
282282++
283283++int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
284284++ // Have 'segment' point to the first segment for now, 'root'.
285285++ HuffmanTablesSegment* const root = &huffman_tables->root;
286286++ huffman_tables->curr_segment = root;
287287++ // Allocate root.
288288++ root->start = (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
289289++ if (root->start == NULL) return 0;
290290++ root->curr_table = root->start;
291291++ root->next = NULL;
292292++ root->size = size;
293293++ return 1;
294294++}
295295++
296296++void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
297297++ HuffmanTablesSegment *current, *next;
298298++ if (huffman_tables == NULL) return;
299299++ // Free the root node.
300300++ current = &huffman_tables->root;
301301++ next = current->next;
302302++ WebPSafeFree(current->start);
303303++ current->start = NULL;
304304++ current->next = NULL;
305305++ current = next;
306306++ // Free the following nodes.
307307++ while (current != NULL) {
308308++ next = current->next;
309309++ WebPSafeFree(current->start);
310310++ WebPSafeFree(current);
311311++ current = next;
312312++ }
313313++}
314314+diff --git a/src/utils/huffman_utils.h b/src/utils/huffman_utils.h
315315+index 13b7ad1a..98415c53 100644
316316+--- a/src/utils/huffman_utils.h
317317++++ b/src/utils/huffman_utils.h
318318+@@ -43,6 +43,29 @@ typedef struct {
319319+ // or non-literal symbol otherwise
320320+ } HuffmanCode32;
321321+322322++// Contiguous memory segment of HuffmanCodes.
323323++typedef struct HuffmanTablesSegment {
324324++ HuffmanCode* start;
325325++ // Pointer to where we are writing into the segment. Starts at 'start' and
326326++ // cannot go beyond 'start' + 'size'.
327327++ HuffmanCode* curr_table;
328328++ // Pointer to the next segment in the chain.
329329++ struct HuffmanTablesSegment* next;
330330++ int size;
331331++} HuffmanTablesSegment;
332332++
333333++// Chained memory segments of HuffmanCodes.
334334++typedef struct HuffmanTables {
335335++ HuffmanTablesSegment root;
336336++ // Currently processed segment. At first, this is 'root'.
337337++ HuffmanTablesSegment* curr_segment;
338338++} HuffmanTables;
339339++
340340++// Allocates a HuffmanTables with 'size' contiguous HuffmanCodes. Returns 0 on
341341++// memory allocation error, 1 otherwise.
342342++int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables);
343343++void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables);
344344++
345345+ #define HUFFMAN_PACKED_BITS 6
346346+ #define HUFFMAN_PACKED_TABLE_SIZE (1u << HUFFMAN_PACKED_BITS)
347347+348348+@@ -78,9 +101,7 @@ void VP8LHtreeGroupsFree(HTreeGroup* const htree_groups);
349349+ // the huffman table.
350350+ // Returns built table size or 0 in case of error (invalid tree or
351351+ // memory error).
352352+-// If root_table is NULL, it returns 0 if a lookup cannot be built, something
353353+-// > 0 otherwise (but not the table size).
354354+-int VP8LBuildHuffmanTable(HuffmanCode* const root_table, int root_bits,
355355++int VP8LBuildHuffmanTable(HuffmanTables* const root_table, int root_bits,
356356+ const int code_lengths[], int code_lengths_size);
357357+358358+ #ifdef __cplusplus
359359+--
360360+2.41.0
361361+
+8
pkgs/development/libraries/libwebp/default.nix
···3636 hash = "sha256-Q94avvKjPdwdGt5ADo30cf2V4T7MCTubDHJxTtbG4xQ=";
3737 };
38383939+ patches = [
4040+ # Commit 902bc919 from upstream, mangled slightly to apply onto 1.3.1.
4141+ # There is currently (2023-09-12) no confirmation that this is the fix for
4242+ # CVE-2023-4863, but it is linked to the right crbug, and matches the
4343+ # description of that (critical sev, exploited in the wild) CVE.
4444+ ./CVE-2023-4863.patch
4545+ ];
4646+3947 configureFlags = [
4048 (lib.enableFeature threadingSupport "threading")
4149 (lib.enableFeature openglSupport "gl")
···11-{ buildPythonPackage
22-, lib
11+{ lib
22+, buildPythonPackage
33, cmake
44+, numpy
55+, pillow
46, pybind11
57, zxing-cpp
66-, numpy
77-, pillow
88}:
991010buildPythonPackage rec {
1111 pname = "zxing_cpp";
1212- inherit (zxing-cpp) src version;
1212+ inherit (zxing-cpp) src version meta;
13131414 sourceRoot = "${src.name}/wrappers/python";
1515- patches = [
1616- ./use-nixpkgs-pybind11.patch
1717- ];
1515+1816 dontUseCmakeConfigure = true;
19172018 propagatedBuildInputs = [
···2927 nativeCheckInputs = [
3028 pillow
3129 ];
3232-3333- meta = with lib; {
3434- homepage = "https://github.com/zxing-cpp/zxing-cpp";
3535- description = "Python bindings for C++ port of zxing (a Java barcode image processing library)";
3636- longDescription = ''
3737- ZXing-C++ ("zebra crossing") is an open-source, multi-format 1D/2D barcode
3838- image processing library implemented in C++.
3939-4040- It was originally ported from the Java ZXing Library but has been
4141- developed further and now includes many improvements in terms of quality
4242- and performance. It can both read and write barcodes in a number of
4343- formats.
4444- '';
4545- license = licenses.asl20;
4646- maintainers = with maintainers; [ lukegb ];
4747- platforms = with platforms; unix;
4848- };
4930}
···2121 })
2222 ];
23232424+ # Our version is good; the check is bad.
2525+ configureFlags = [ "--without-zlib-version-check" ];
2626+2427 buildInputs = [ openssl zlib ];
25282629 meta = with lib; {
-1
pkgs/top-level/aliases.nix
···18781878 inherit (libsForQt5.mauiPackages) vvave; # added 2022-05-17
1879187918801880 ### W ###
18811881- wafHook = waf.hook; # Added 2023-08-23
18821881 wavesurfer = throw "wavesurfer has been removed: depended on snack which has been removed"; # Added 2022-04-21
18831882 waybar-hyprland = throw "waybar-hyprland has been removed: hyprland support is now built into waybar by default."; # Added 2023-08-21
18841883 way-cooler = throw "way-cooler is abandoned by its author: https://way-cooler.org/blog/2020/01/09/way-cooler-post-mortem.html"; # Added 2020-01-13