From da17f6b81c2c3c7fb0f295311c090541b9a887f8 Mon Sep 17 00:00:00 2001 From: Anna Zhukova <28830446+bindreams@users.noreply.github.com> Date: Thu, 2 May 2024 23:06:53 +0300 Subject: [PATCH] Generate native enums --- pyproject.toml | 3 - src/zint-stubs/__init__.pyi | 509 +----------------- src/zint/CMakeLists.txt | 14 +- src/zint/scripts/generate-enums.py | 269 +++++---- .../scripts/generate-enums.requirements.txt | 2 - src/zint/src/enum_util.hpp | 101 ++++ src/zint/src/enums.hpp | 14 + src/zint/src/generated/enum_declarations.hpp | 20 + src/zint/src/generated/enums.hpp | 375 ------------- src/zint/src/generated/enums.inc | 169 ++++++ src/zint/src/main.cpp | 8 +- tests/test_stub.py | 5 +- 12 files changed, 457 insertions(+), 1032 deletions(-) delete mode 100644 src/zint/scripts/generate-enums.requirements.txt create mode 100644 src/zint/src/enum_util.hpp create mode 100644 src/zint/src/enums.hpp create mode 100644 src/zint/src/generated/enum_declarations.hpp delete mode 100644 src/zint/src/generated/enums.hpp create mode 100644 src/zint/src/generated/enums.inc diff --git a/pyproject.toml b/pyproject.toml index b56bb664..9542aba4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -62,9 +62,6 @@ requires = [ "pybind11 >= 2.12, < 3", # Build dependencies from CMake. Please keep this in sync with relevant requirements files. "pip >= 24", - # src/zint/scripts/generate-enums.requirements.txt - "clang-format >= 18", - "varformat", # src/zint/scripts/generate-stub.requirements.txt "pybind11-stubgen", "numpy", diff --git a/src/zint-stubs/__init__.pyi b/src/zint-stubs/__init__.pyi index 6f9344b0..84c6269a 100644 --- a/src/zint-stubs/__init__.pyi +++ b/src/zint-stubs/__init__.pyi @@ -3,6 +3,7 @@ A barcode encoding library supporting over 50 symbologies. """ from __future__ import annotations +import enum import numpy import typing import typing_extensions @@ -26,43 +27,7 @@ __all__: list = [ "WarningLevel", ] -class CapabilityFlags: - """ - Capability flags (ZBarcode_Cap() `cap_flag`) - - Members: - - HRT : Prints Human Readable Text? - - STACKABLE : Is stackable? - - EANUPC : Is EAN/UPC? - - EXTENDABLE : Legacy - - COMPOSITE : Can have composite data? - - ECI : Supports Extended Channel Interpretations? - - GS1 : Supports GS1 data? - - DOTTY : Can be output as dots? - - QUIET_ZONES : Has default quiet zones? - - FIXED_RATIO : Has fixed width-to-height (aspect) ratio? - - READER_INIT : Supports Reader Initialisation? - - FULL_MULTIBYTE : Supports full-multibyte option? - - MASK : Is mask selectable? - - STRUCTAPP : Supports Structured Append? - - COMPLIANT_HEIGHT : Has compliant height? - """ - +class CapabilityFlags(enum.Enum): COMPLIANT_HEIGHT: typing.ClassVar[ CapabilityFlags ] # value = @@ -72,7 +37,6 @@ class CapabilityFlags: DOTTY: typing.ClassVar[CapabilityFlags] # value = EANUPC: typing.ClassVar[CapabilityFlags] # value = ECI: typing.ClassVar[CapabilityFlags] # value = - EXTENDABLE: typing.ClassVar[CapabilityFlags] # value = FIXED_RATIO: typing.ClassVar[ CapabilityFlags ] # value = @@ -94,37 +58,8 @@ class CapabilityFlags: STRUCTAPP: typing.ClassVar[ CapabilityFlags ] # value = - __members__: typing.ClassVar[ - dict[str, CapabilityFlags] - ] # value = {'HRT': , 'STACKABLE': , 'EANUPC': , 'EXTENDABLE': , 'COMPOSITE': , 'ECI': , 'GS1': , 'DOTTY': , 'QUIET_ZONES': , 'FIXED_RATIO': , 'READER_INIT': , 'FULL_MULTIBYTE': , 'MASK': , 'STRUCTAPP': , 'COMPLIANT_HEIGHT': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - -class DataMatrixOptions: - """ - Data Matrix specific options (`symbol->option_3`) - - Members: - - SQUARE : Only consider square versions on automatic symbol size selection - - DMRE : Consider DMRE versions on automatic symbol size selection - - ISO_144 : Use ISO instead of "de facto" format for 144x144 (i.e. don't skew ECC) - """ +class DataMatrixOptions(enum.Enum): DMRE: typing.ClassVar[DataMatrixOptions] # value = ISO_144: typing.ClassVar[ DataMatrixOptions @@ -132,50 +67,8 @@ class DataMatrixOptions: SQUARE: typing.ClassVar[ DataMatrixOptions ] # value = - __members__: typing.ClassVar[ - dict[str, DataMatrixOptions] - ] # value = {'SQUARE': , 'DMRE': , 'ISO_144': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - -class InputMode: - """ - Values for `Symbol.input_mode` - - Members: - - DATA : Binary - - UNICODE : UTF-8 - - GS1 : GS1. The following may be OR-ed with above - - ESCAPE : Process escape sequences - - GS1PARENS : Process parentheses as GS1 AI delimiters (instead of square brackets) - - GS1NOCHECK : Do not check validity of GS1 data (except that printable ASCII only) - HEIGHTPERROW : Interpret `height` as per-row rather than as overall height - - FAST : Use faster if less optimal encodation or other shortcuts if available. Note: affects DATAMATRIX, MICROPDF417, PDF417, QRCODE & UPNQR only - - EXTRA_ESCAPE : Process special symbology-specific escape sequences. Note: currently Code 128 only - """ - - DATA: typing.ClassVar[InputMode] # value = +class InputMode(enum.Flag): ESCAPE: typing.ClassVar[InputMode] # value = EXTRA_ESCAPE: typing.ClassVar[InputMode] # value = FAST: typing.ClassVar[InputMode] # value = @@ -184,67 +77,8 @@ class InputMode: GS1PARENS: typing.ClassVar[InputMode] # value = HEIGHTPERROW: typing.ClassVar[InputMode] # value = UNICODE: typing.ClassVar[InputMode] # value = - __members__: typing.ClassVar[ - dict[str, InputMode] - ] # value = {'DATA': , 'UNICODE': , 'GS1': , 'ESCAPE': , 'GS1PARENS': , 'GS1NOCHECK': , 'HEIGHTPERROW': , 'FAST': , 'EXTRA_ESCAPE': } - def __eq__(self, other: typing.Any) -> bool: ... - def __ge__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __gt__(self, other: typing.Any) -> bool: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __le__(self, other: typing.Any) -> bool: ... - def __lt__(self, other: typing.Any) -> bool: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - -class OutputOptions: - """ - Values for `Symbol.output_options` - - Members: - - BARCODE_BIND_TOP : Boundary bar above the symbol only (not below), does not affect stacking. Note: value was once used by the legacy (never-used) BARCODE_NO_ASCII - - BARCODE_BIND : Boundary bars above & below the symbol and between stacked symbols - - BARCODE_BOX : Box around symbol - - BARCODE_STDOUT : Output to stdout - - READER_INIT : Reader Initialisation (Programming) - - SMALL_TEXT : Use smaller font - - BOLD_TEXT : Use bold font - - CMYK_COLOUR : CMYK colour space (Encapsulated PostScript and TIF) - - BARCODE_DOTTY_MODE : Plot a matrix symbol using dots rather than squares - - GS1_GS_SEPARATOR : Use GS instead of FNC1 as GS1 separator (Data Matrix) - - OUT_BUFFER_INTERMEDIATE : Return ASCII values in bitmap buffer (OUT_BUFFER only) - - BARCODE_QUIET_ZONES : Add compliant quiet zones (additional to any specified whitespace). Note: CODE16K, CODE49, CODABLOCKF, ITF14, EAN/UPC have default quiet zones - - BARCODE_NO_QUIET_ZONES : Disable quiet zones, notably those with defaults as listed above - - COMPLIANT_HEIGHT : Warn if height not compliant, or use standard height (if any) as default - - EANUPC_GUARD_WHITESPACE : Add quiet zone indicators ("<"/">") to HRT whitespace (EAN/UPC) - - EMBED_VECTOR_FONT : Embed font in vector output - currently only for SVG output - """ +class OutputOptions(enum.Flag): BARCODE_BIND: typing.ClassVar[ OutputOptions ] # value = @@ -289,57 +123,11 @@ class OutputOptions: OutputOptions ] # value = SMALL_TEXT: typing.ClassVar[OutputOptions] # value = - __members__: typing.ClassVar[ - dict[str, OutputOptions] - ] # value = {'BARCODE_BIND_TOP': , 'BARCODE_BIND': , 'BARCODE_BOX': , 'BARCODE_STDOUT': , 'READER_INIT': , 'SMALL_TEXT': , 'BOLD_TEXT': , 'CMYK_COLOUR': , 'BARCODE_DOTTY_MODE': , 'GS1_GS_SEPARATOR': , 'OUT_BUFFER_INTERMEDIATE': , 'BARCODE_QUIET_ZONES': , 'BARCODE_NO_QUIET_ZONES': , 'COMPLIANT_HEIGHT': , 'EANUPC_GUARD_WHITESPACE': , 'EMBED_VECTOR_FONT': } - def __eq__(self, other: typing.Any) -> bool: ... - def __ge__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __gt__(self, other: typing.Any) -> bool: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __le__(self, other: typing.Any) -> bool: ... - def __lt__(self, other: typing.Any) -> bool: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - -class QrFamilyOptions: - """ - QR, Han Xin, Grid Matrix specific options (`symbol->option_3`) - - Members: - - FULL_MULTIBYTE : Enable Kanji/Hanzi compression for Latin-1 & binary data - """ +class QrFamilyOptions(enum.Enum): FULL_MULTIBYTE: typing.ClassVar[ QrFamilyOptions ] # value = - __members__: typing.ClassVar[ - dict[str, QrFamilyOptions] - ] # value = {'FULL_MULTIBYTE': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... class Seg: """ @@ -614,13 +402,13 @@ class Symbol: @height.setter def height(self, arg1: float) -> None: ... @property - def input_mode(self) -> int: + def input_mode(self) -> InputMode: """ Encoding of input data (see DATA_MODE etc below). Default DATA_MODE """ @input_mode.setter - def input_mode(self, arg1: int) -> None: ... + def input_mode(self, arg1: InputMode) -> None: ... @property def option_1(self) -> int: """ @@ -763,211 +551,7 @@ class Symbol: Width of the generated symbol (output only) """ -class Symbology: - """ - Values for `Symbol.symbology` - - Members: - - CODE11 : Code 11 - - C25STANDARD : 2 of 5 Standard (Matrix) - - C25INTER : 2 of 5 Interleaved - - C25IATA : 2 of 5 IATA - - C25LOGIC : 2 of 5 Data Logic - - C25IND : 2 of 5 Industrial - - CODE39 : Code 39 - - EXCODE39 : Extended Code 39 - - EANX : EAN (European Article Number) - - EANX_CHK : EAN + Check Digit - - GS1_128 : GS1-128 - - CODABAR : Codabar - - CODE128 : Code 128 - - DPLEIT : Deutsche Post Leitcode - - DPIDENT : Deutsche Post Identcode - - CODE16K : Code 16k - - CODE49 : Code 49 - - CODE93 : Code 93 - - FLAT : Flattermarken - - DBAR_OMN : GS1 DataBar Omnidirectional - - DBAR_LTD : GS1 DataBar Limited - - DBAR_EXP : GS1 DataBar Expanded - - TELEPEN : Telepen Alpha - - UPCA : UPC-A - - UPCA_CHK : UPC-A + Check Digit - - UPCE : UPC-E - - UPCE_CHK : UPC-E + Check Digit - - POSTNET : USPS (U.S. Postal Service) POSTNET - - MSI_PLESSEY : MSI Plessey - - FIM : Facing Identification Mark - - LOGMARS : LOGMARS - - PHARMA : Pharmacode One-Track - - PZN : Pharmazentralnummer - - PHARMA_TWO : Pharmacode Two-Track - - CEPNET : Brazilian CEPNet Postal Code - - PDF417 : PDF417 - - PDF417COMP : Compact PDF417 (Truncated PDF417) - - MAXICODE : MaxiCode - - QRCODE : QR Code - - CODE128AB : Code 128 (Suppress Code Set C) - - AUSPOST : Australia Post Standard Customer - - AUSREPLY : Australia Post Reply Paid - - AUSROUTE : Australia Post Routing - - AUSREDIRECT : Australia Post Redirection - - ISBNX : ISBN - - RM4SCC : Royal Mail 4-State Customer Code - - DATAMATRIX : Data Matrix (ECC200) - - EAN14 : EAN-14 - - VIN : Vehicle Identification Number - - CODABLOCKF : Codablock-F - - NVE18 : NVE-18 (SSCC-18) - - JAPANPOST : Japanese Postal Code - - KOREAPOST : Korea Post - - DBAR_STK : GS1 DataBar Stacked - - DBAR_OMNSTK : GS1 DataBar Stacked Omnidirectional - - DBAR_EXPSTK : GS1 DataBar Expanded Stacked - - PLANET : USPS PLANET - - MICROPDF417 : MicroPDF417 - - USPS_IMAIL : USPS Intelligent Mail (OneCode) - - PLESSEY : UK Plessey - - TELEPEN_NUM : Telepen Numeric - - ITF14 : ITF-14 - - KIX : Dutch Post KIX Code - - AZTEC : Aztec Code - - DAFT : DAFT Code - - DPD : DPD Code - - MICROQR : Micro QR Code - - HIBC_128 : HIBC (Health Industry Barcode) Code 128 - - HIBC_39 : HIBC Code 39 - - HIBC_DM : HIBC Data Matrix - - HIBC_QR : HIBC QR Code - - HIBC_PDF : HIBC PDF417 - - HIBC_MICPDF : HIBC MicroPDF417 - - HIBC_BLOCKF : HIBC Codablock-F - - HIBC_AZTEC : HIBC Aztec Code - - DOTCODE : DotCode - - HANXIN : Han Xin (Chinese Sensible) Code - - MAILMARK_2D : Royal Mail 2D Mailmark (CMDM) (Data Matrix) - - UPU_S10 : Universal Postal Union S10 - - MAILMARK_4S : Royal Mail 4-State Mailmark - - AZRUNE : Aztec Runes - - CODE32 : Code 32 - - EANX_CC : EAN Composite - - GS1_128_CC : GS1-128 Composite - - DBAR_OMN_CC : GS1 DataBar Omnidirectional Composite - - DBAR_LTD_CC : GS1 DataBar Limited Composite - - DBAR_EXP_CC : GS1 DataBar Expanded Composite - - UPCA_CC : UPC-A Composite - - UPCE_CC : UPC-E Composite - - DBAR_STK_CC : GS1 DataBar Stacked Composite - - DBAR_OMNSTK_CC : GS1 DataBar Stacked Omnidirectional Composite - - DBAR_EXPSTK_CC : GS1 DataBar Expanded Stacked Composite - - CHANNEL : Channel Code - - CODEONE : Code One - - GRIDMATRIX : Grid Matrix - - UPNQR : UPNQR (Univerzalnega Plačilnega Naloga QR) - - ULTRA : Ultracode - - RMQR : Rectangular Micro QR Code (rMQR) - - BC412 : IBM BC412 (SEMI T1-95) - """ - +class Symbology(enum.Enum): AUSPOST: typing.ClassVar[Symbology] # value = AUSREDIRECT: typing.ClassVar[Symbology] # value = AUSREPLY: typing.ClassVar[Symbology] # value = @@ -1071,53 +655,11 @@ class Symbology: UPU_S10: typing.ClassVar[Symbology] # value = USPS_IMAIL: typing.ClassVar[Symbology] # value = VIN: typing.ClassVar[Symbology] # value = - __members__: typing.ClassVar[ - dict[str, Symbology] - ] # value = {'CODE11': , 'C25STANDARD': , 'C25INTER': , 'C25IATA': , 'C25LOGIC': , 'C25IND': , 'CODE39': , 'EXCODE39': , 'EANX': , 'EANX_CHK': , 'GS1_128': , 'CODABAR': , 'CODE128': , 'DPLEIT': , 'DPIDENT': , 'CODE16K': , 'CODE49': , 'CODE93': , 'FLAT': , 'DBAR_OMN': , 'DBAR_LTD': , 'DBAR_EXP': , 'TELEPEN': , 'UPCA': , 'UPCA_CHK': , 'UPCE': , 'UPCE_CHK': , 'POSTNET': , 'MSI_PLESSEY': , 'FIM': , 'LOGMARS': , 'PHARMA': , 'PZN': , 'PHARMA_TWO': , 'CEPNET': , 'PDF417': , 'PDF417COMP': , 'MAXICODE': , 'QRCODE': , 'CODE128AB': , 'AUSPOST': , 'AUSREPLY': , 'AUSROUTE': , 'AUSREDIRECT': , 'ISBNX': , 'RM4SCC': , 'DATAMATRIX': , 'EAN14': , 'VIN': , 'CODABLOCKF': , 'NVE18': , 'JAPANPOST': , 'KOREAPOST': , 'DBAR_STK': , 'DBAR_OMNSTK': , 'DBAR_EXPSTK': , 'PLANET': , 'MICROPDF417': , 'USPS_IMAIL': , 'PLESSEY': , 'TELEPEN_NUM': , 'ITF14': , 'KIX': , 'AZTEC': , 'DAFT': , 'DPD': , 'MICROQR': , 'HIBC_128': , 'HIBC_39': , 'HIBC_DM': , 'HIBC_QR': , 'HIBC_PDF': , 'HIBC_MICPDF': , 'HIBC_BLOCKF': , 'HIBC_AZTEC': , 'DOTCODE': , 'HANXIN': , 'MAILMARK_2D': , 'UPU_S10': , 'MAILMARK_4S': , 'AZRUNE': , 'CODE32': , 'EANX_CC': , 'GS1_128_CC': , 'DBAR_OMN_CC': , 'DBAR_LTD_CC': , 'DBAR_EXP_CC': , 'UPCA_CC': , 'UPCE_CC': , 'DBAR_STK_CC': , 'DBAR_OMNSTK_CC': , 'DBAR_EXPSTK_CC': , 'CHANNEL': , 'CODEONE': , 'GRIDMATRIX': , 'UPNQR': , 'ULTRA': , 'RMQR': , 'BC412': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - -class UltracodeOptions: - """ - Ultracode specific option (`symbol->option_3`) - - Members: - - ULTRA_COMPRESSION : Enable Ultracode compression (experimental) - """ +class UltracodeOptions(enum.Enum): ULTRA_COMPRESSION: typing.ClassVar[ UltracodeOptions ] # value = - __members__: typing.ClassVar[ - dict[str, UltracodeOptions] - ] # value = {'ULTRA_COMPRESSION': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... class Vector: """ @@ -1328,36 +870,9 @@ class VectorStrings: def __iter__(self) -> typing.Iterator[VectorString]: ... def __len__(self) -> int: ... -class WarningLevel: - """ - Warning level (`symbol->warn_level`) - - Members: - - DEFAULT : Default behaviour - - FAIL_ALL : Treat warning as error - """ - +class WarningLevel(enum.Enum): DEFAULT: typing.ClassVar[WarningLevel] # value = FAIL_ALL: typing.ClassVar[WarningLevel] # value = - __members__: typing.ClassVar[ - dict[str, WarningLevel] - ] # value = {'DEFAULT': , 'FAIL_ALL': } - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... __upstream_version__: str = "2.13.0" -__version__: str = "0.1.0" +__version__: str = "1.0.0" diff --git a/src/zint/CMakeLists.txt b/src/zint/CMakeLists.txt index 4081b3ac..424250d1 100644 --- a/src/zint/CMakeLists.txt +++ b/src/zint/CMakeLists.txt @@ -40,7 +40,7 @@ set_target_properties(zint-static PROPERTIES set(TARGET_NAME "zint_bindings") pybind11_add_module(${TARGET_NAME} MODULE src/main.cpp) -file(GLOB_RECURSE ${TARGET_NAME}_HEADERS CONFIGURE_DEPENDS "src/*.hpp") +file(GLOB_RECURSE ${TARGET_NAME}_HEADERS CONFIGURE_DEPENDS "src/*.hpp" "src/*.inc") target_sources(${TARGET_NAME} PRIVATE FILE_SET HEADERS BASE_DIRS src FILES ${${TARGET_NAME}_HEADERS}) set_target_properties(${TARGET_NAME} PROPERTIES OUTPUT_NAME zint @@ -61,17 +61,13 @@ install(TARGETS ${TARGET_NAME} LIBRARY DESTINATION . COMPONENT ${TARGET_NAME}) # generate-enums.py script ============================================================================================= find_package(Python3 COMPONENTS Interpreter REQUIRED) -execute_process( - COMMAND pip --disable-pip-version-check - install -r "${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate-enums.requirements.txt" - COMMAND_ERROR_IS_FATAL ANY -) - add_custom_target(_generate_enums_hpp COMMAND "${Python3_EXECUTABLE}" scripts/generate-enums.py DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/generate-enums.py" - BYPRODUCTS "${CMAKE_CURRENT_SOURCE_DIR}/src/generated/enums.hpp" - COMMENT "Creating src/generated/enums.hpp" + BYPRODUCTS + "${CMAKE_CURRENT_SOURCE_DIR}/src/generated/enums.inc" + "${CMAKE_CURRENT_SOURCE_DIR}/src/generated/enums_declarations.hpp" + COMMENT "Generating enum files" WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" VERBATIM ) diff --git a/src/zint/scripts/generate-enums.py b/src/zint/scripts/generate-enums.py index be110b88..574fd93f 100644 --- a/src/zint/scripts/generate-enums.py +++ b/src/zint/scripts/generate-enums.py @@ -1,13 +1,11 @@ """Generate src/generated/enums.hpp file. Run this from the root directory.""" +import io import json import re -import subprocess as sp import sys -import textwrap - -import clang_format as cf -import varformat as vf +from dataclasses import dataclass +from textwrap import dedent re_base_define = r"^#define (\w+) +((?:0x)?\d+)" """`#define BARCODE_CODE128 0x01`""" @@ -21,6 +19,15 @@ re_define = re_base_define + " *" + re_comment + "(?:" + re_comment_note + ")?" +@dataclass +class EnumInfo: + name: str + values: list + cpp_base: str = "int" + py_base: str = "enum.Enum" + docstring: str = "" + + def find_line_re(pattern, source: str, start=0): m = re.search(pattern, source[start:], re.MULTILINE | re.DOTALL) if m: @@ -29,17 +36,12 @@ def find_line_re(pattern, source: str, start=0): return None -def clang_format(text: str): - exe = cf._get_executable("clang-format") - return sp.check_output([exe, "-"], encoding="utf-8", input=text) - - def escape_string(s: str): """Escape a string for double quotes in C++.""" return json.dumps(s, ensure_ascii=False)[1:-1] -def parse_enum( +def parse_enum_values( source: str, *, header: str, @@ -95,156 +97,143 @@ def enum_definition(enum, *, class_name: str, base_type: str = "int"): return f"enum class {class_name} : {base_type} {{ {values} }};" -def enum_binding(enum, *, class_name: str, docstring: str, arithmetic=False): - values = "".join(f'.value("{name}", {class_name}::{name}, "{escape_string(comment)}")' for name, _, comment in enum) - - if arithmetic == True: - arithmetic_tag = "py::arithmetic{}," - else: - arithmetic_tag = "" +def write_enum_macro(fd, enum: EnumInfo): + fd.write(f'ENUM_BEGIN({enum.name}, {enum.cpp_base}, "{enum.py_base}", "{escape_string(enum.docstring)}")\n') - return f'py::enum_<{class_name}>(m, "{class_name}", {arithmetic_tag} "{escape_string(docstring)}") {values};' + for name, value, value_docstring in enum.values: + fd.write(f'ENUM_VALUE({enum.name}, {name}, {value}, "{escape_string(value_docstring)}")\n') + fd.write(f"ENUM_END({enum.name})\n\n") -def main(): - with open("external/zint/backend/zint.h", "r", encoding="utf-8") as f: - source = f.read() - # Symbology enum - symbology_enum = parse_enum( - source, - header=re.escape("/* Symbologies (`symbol->symbology`) */"), - prefix="BARCODE_", - blacklist=lambda name, _, comment: comment == "Legacy" or name == "LAST", - ) +def p11x_declare_enum(fd, enum: EnumInfo): + # P11X_DECLARE_ENUM( + # "NameOfPythonEnum", + # "enum.Enum", // or "enum.IntEnum", etc. + # {"PyNameA", CEnumMemberA}, {"PyNameB", CEnumMemberB}, ... + # ) - output_options_enum = parse_enum( - source, - header=re.escape("/* Output options (`symbol->output_options`) */"), - ) + fd.write(f'P11X_DECLARE_ENUM("{enum.name}", "{enum.py_base}"') - imput_mode_enum = parse_enum( - source, - header=re.escape("/* Input data types (`symbol->input_mode`) */"), - footer=r"^\/\*(?! The following may be OR-ed with above)", # Do not terminate on a top-level comment - suffix="_MODE", - ) + for name, value, value_docstring in enum.values: + fd.write(f', {{"{name}", {enum.name}::{name}}}') - datamatrix_options_enum = parse_enum( - source, - header=re.escape("/* Data Matrix specific options (`symbol->option_3`) */"), - prefix="DM_", - ) + fd.write(")\n") - qr_family_options_enum = parse_enum( - source, - header=re.escape("/* QR, Han Xin, Grid Matrix specific options (`symbol->option_3`) */"), - prefix="ZINT_", - ) - ultracode_options_enum = parse_enum( - source, - header=re.escape("/* Ultracode specific option (`symbol->option_3`) */"), - ) +def main(): + with open("external/zint/backend/zint.h", "r", encoding="utf-8") as f: + source = f.read() - warning_level_enum = parse_enum( - source, - header=re.escape("/* Warning level (`symbol->warn_level`) */"), - prefix="WARN_", - ) + enums = [ + EnumInfo( + name="Symbology", + docstring="Values for `Symbol.symbology`", + values=parse_enum_values( + source, + header=re.escape("/* Symbologies (`symbol->symbology`) */"), + prefix="BARCODE_", + blacklist=lambda name, _, comment: comment == "Legacy" or name == "LAST", + ), + ), + EnumInfo( + name="OutputOptions", + docstring="Values for `Symbol.output_options`", + py_base="enum.Flag", + values=parse_enum_values( + source, + header=re.escape("/* Output options (`symbol->output_options`) */"), + ), + ), + EnumInfo( + name="InputMode", + docstring="Values for `Symbol.input_mode`", + py_base="enum.Flag", + values=parse_enum_values( + source, + header=re.escape("/* Input data types (`symbol->input_mode`) */"), + footer=r"^\/\*(?! The following may be OR-ed with above)", # Do not terminate on a top-level comment + suffix="_MODE", + ), + ), + EnumInfo( + name="DataMatrixOptions", + docstring="Data Matrix specific options (`symbol->option_3`)", + values=parse_enum_values( + source, + header=re.escape("/* Data Matrix specific options (`symbol->option_3`) */"), + prefix="DM_", + ), + ), + EnumInfo( + name="QrFamilyOptions", + docstring="QR, Han Xin, Grid Matrix specific options (`symbol->option_3`)", + values=parse_enum_values( + source, + header=re.escape("/* QR, Han Xin, Grid Matrix specific options (`symbol->option_3`) */"), + prefix="ZINT_", + ), + ), + EnumInfo( + name="UltracodeOptions", + docstring="Ultracode specific option (`symbol->option_3`)", + values=parse_enum_values( + source, + header=re.escape("/* Ultracode specific option (`symbol->option_3`) */"), + ), + ), + EnumInfo( + name="WarningLevel", + docstring="Warning level (`symbol->warn_level`)", + values=parse_enum_values( + source, + header=re.escape("/* Warning level (`symbol->warn_level`) */"), + prefix="WARN_", + ), + ), + EnumInfo( + name="CapabilityFlags", + docstring="Capability flags (ZBarcode_Cap() `cap_flag`)", + cpp_base="unsigned int", + values=parse_enum_values( + source, + header=re.escape("/* Capability flags (ZBarcode_Cap() `cap_flag`) */"), + prefix="ZINT_CAP_", + blacklist=lambda _1, _2, comment: comment == "Legacy", + ), + ), + ] - capability_flags_enum = parse_enum( - source, - header=re.escape("/* Capability flags (ZBarcode_Cap() `cap_flag`) */"), - prefix="ZINT_CAP_", - ) + # Write files ------------------------------------------------------------------------------------------------------ + # Write enums.inc + with open("src/generated/enums.inc", "w", encoding="utf-8", newline="\n") as fd: + for enum in enums: + write_enum_macro(fd, enum) - # Write file ------------------------------------------------------------------------------------------------------- - template = textwrap.dedent( + enum_declarations_template = dedent( """\ - /// This file was generated automatically by scripts/generate-enums.py. Please do not edit it manually. + /// This file was generated automatically by `scripts/generate-enums.py`. Please do not edit it manually. #pragma once - #include - namespace py = pybind11; + #include "../enum_util.hpp" + #include "../enums.hpp" - ${code} + #pragma warning(push) + #pragma warning(disable : 4706) // assignment within conditional expression - inline void init_enum_bindings(pybind11::module_& m) { - ${bindings} - } + {contents} + + #pragma warning(pop) """ ) - text = vf.format( - template, - code="\n".join( - [ - enum_definition(symbology_enum, class_name="Symbology"), - enum_definition(output_options_enum, class_name="OutputOptions"), - enum_definition(imput_mode_enum, class_name="InputMode"), - enum_definition(datamatrix_options_enum, class_name="DataMatrixOptions"), - enum_definition(qr_family_options_enum, class_name="QrFamilyOptions"), - enum_definition(ultracode_options_enum, class_name="UltracodeOptions"), - enum_definition(warning_level_enum, class_name="WarningLevel"), - enum_definition( - capability_flags_enum, - class_name="CapabilityFlags", - base_type="unsigned int", - ), - ] - ), - bindings="\n".join( - [ - enum_binding( - symbology_enum, - class_name="Symbology", - docstring="Values for `Symbol.symbology`", - ), - enum_binding( - output_options_enum, - class_name="OutputOptions", - docstring="Values for `Symbol.output_options`", - arithmetic=True, - ), - enum_binding( - imput_mode_enum, - class_name="InputMode", - docstring="Values for `Symbol.input_mode`", - arithmetic=True, - ), - enum_binding( - datamatrix_options_enum, - class_name="DataMatrixOptions", - docstring="Data Matrix specific options (`symbol->option_3`)", - ), - enum_binding( - qr_family_options_enum, - class_name="QrFamilyOptions", - docstring="QR, Han Xin, Grid Matrix specific options (`symbol->option_3`)", - ), - enum_binding( - ultracode_options_enum, - class_name="UltracodeOptions", - docstring="Ultracode specific option (`symbol->option_3`)", - ), - enum_binding( - warning_level_enum, - class_name="WarningLevel", - docstring="Warning level (`symbol->warn_level`)", - ), - enum_binding( - capability_flags_enum, - class_name="CapabilityFlags", - docstring="Capability flags (ZBarcode_Cap() `cap_flag`)", - ), - ] - ), - ) + # Write enum_declarations.hpp + contents = io.StringIO() + for enum in enums: + p11x_declare_enum(contents, enum) - text = clang_format(text) - with open("src/generated/enums.hpp", "w", encoding="utf-8", newline="\n") as f: - f.write(text) + with open("src/generated/enum_declarations.hpp", "w", encoding="utf-8", newline="\n") as f: + f.write(enum_declarations_template.format(contents=contents.getvalue())) if __name__ == "__main__": diff --git a/src/zint/scripts/generate-enums.requirements.txt b/src/zint/scripts/generate-enums.requirements.txt deleted file mode 100644 index d0049063..00000000 --- a/src/zint/scripts/generate-enums.requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -clang-format >= 18 -varformat diff --git a/src/zint/src/enum_util.hpp b/src/zint/src/enum_util.hpp new file mode 100644 index 00000000..d47c7402 --- /dev/null +++ b/src/zint/src/enum_util.hpp @@ -0,0 +1,101 @@ +// This magic was borrowed from https://gist.github.com/anntzer/96f27c0b88634dbc61862d08bff46d10 +// +// The ``P11X_DECLARE_ENUM`` macro and the ``p11x::bind_enums`` function +// bind enums to Python's ``enum.Enum`` or one of its subclasses +// (``enum.IntEnum``, ``enum.Flag``, ``enum.IntFlag``) -- unlike +// ``pybind11::enum_`` which uses an unrelated implementation. +// +// Use as follows: +// +// .. code-block:: c++ +// +// // Define module_name.NameOfPythonEnum as an enum.Enum subclass, with +// // members PyNameA, PyNameB, etc. +// +// // This must happen at the toplevel, not within a namespace. +// P11X_DECLARE_ENUM( +// "NameOfPythonEnum", +// "enum.Enum", // or "enum.IntEnum", etc. +// {"PyNameA", CEnumMemberA}, {"PyNameB", CEnumMemberB}, ... +// ) +// +// // This must be within PYBIND11_MODULE, in the same translation unit as +// // P11X_DECLARE_ENUM. +// PYBIND11_MODULE(module_name, m) { +// p11x::bind_enums(m); +// } +// +// The enum members passed to ``P11X_DECLARE_ENUM`` must be actual members of the +// enum class, not integers with the corresponding value -- their type is used to +// infer the C class used by the caster. + +#pragma once + +#include +#include + +// private. +#define P11X_ENUM_TYPE(...) decltype(std::map{std::pair __VA_ARGS__})::mapped_type +#define P11X_CAT2(a, b) a##b +#define P11X_CAT(a, b) P11X_CAT2(a, b) + +namespace p11x { +namespace { +namespace py = pybind11; + +// Holder is (py_base_cls, [(name, value), ...]) before module init; +// converted to the Python class object after init. +auto enums = std::unordered_map{}; + +auto bind_enums(py::module mod) -> void { + for (auto& [py_name, spec] : enums) { + auto const& [py_base_cls, pairs] = spec.cast>(); + mod.attr(py::cast(py_name)) = spec = py::module::import("pydoc").attr("locate")(py_base_cls)( + py_name, pairs, py::arg("module") = mod.attr("__name__") + ); + } +} +} // namespace +} // namespace p11x + +// Immediately converting the args to a vector outside of the lambda avoids +// name collisions. +#define P11X_DECLARE_ENUM(py_name, py_base_cls, ...) \ + namespace p11x { \ + namespace { \ + [[maybe_unused]] auto const P11X_CAT(enum_placeholder_, __COUNTER__) = [](auto args) { \ + py::gil_scoped_acquire gil; \ + using int_t = std::underlying_type_t; \ + auto pairs = std::vector>{}; \ + for (auto& [k, v] : args) { \ + pairs.emplace_back(k, int_t(v)); \ + } \ + p11x::enums[py_name] = pybind11::cast(std::pair{py_base_cls, pairs}); \ + return 0; \ + }(std::vector{std::pair __VA_ARGS__}); \ + } \ + } \ + namespace pybind11::detail { \ + template<> \ + struct type_caster { \ + using type = P11X_ENUM_TYPE(__VA_ARGS__); \ + static_assert(std::is_enum_v, "Not an enum"); \ + PYBIND11_TYPE_CASTER(type, _(py_name)); \ + bool load(handle src, bool) { \ + auto cls = p11x::enums.at(py_name); \ + PyObject* tmp = nullptr; \ + if (pybind11::isinstance(src, cls) && (tmp = PyNumber_Index(src.attr("value").ptr()))) { \ + auto ival = PyLong_AsLong(tmp); \ + value = decltype(value)(ival); \ + Py_DECREF(tmp); \ + return !(ival == -1 && !PyErr_Occurred()); \ + } else { \ + return false; \ + } \ + } \ + static handle cast(decltype(value) obj, return_value_policy, handle) { \ + auto cls = p11x::enums.at(py_name); \ + return cls(std::underlying_type_t(obj)).inc_ref(); \ + } \ + }; \ + } diff --git a/src/zint/src/enums.hpp b/src/zint/src/enums.hpp new file mode 100644 index 00000000..ebc15482 --- /dev/null +++ b/src/zint/src/enums.hpp @@ -0,0 +1,14 @@ +#pragma once +#define ENUM_BEGIN(name, type, _1, _2) enum class name : type { +#define ENUM_VALUE(_1, name, value, _2) name = value, +#define ENUM_END(_1) \ + } \ + ; + +#include "generated/enums.inc" + +#undef ENUM_BEGIN +#undef ENUM_VALUE +#undef ENUM_END + +#include "generated/enum_declarations.hpp" diff --git a/src/zint/src/generated/enum_declarations.hpp b/src/zint/src/generated/enum_declarations.hpp new file mode 100644 index 00000000..8e7d2781 --- /dev/null +++ b/src/zint/src/generated/enum_declarations.hpp @@ -0,0 +1,20 @@ +/// This file was generated automatically by `scripts/generate-enums.py`. Please do not edit it manually. +#pragma once + +#include "../enum_util.hpp" +#include "../enums.hpp" + +#pragma warning(push) +#pragma warning(disable : 4706) // assignment within conditional expression + +P11X_DECLARE_ENUM("Symbology", "enum.Enum", {"CODE11", Symbology::CODE11}, {"C25STANDARD", Symbology::C25STANDARD}, {"C25INTER", Symbology::C25INTER}, {"C25IATA", Symbology::C25IATA}, {"C25LOGIC", Symbology::C25LOGIC}, {"C25IND", Symbology::C25IND}, {"CODE39", Symbology::CODE39}, {"EXCODE39", Symbology::EXCODE39}, {"EANX", Symbology::EANX}, {"EANX_CHK", Symbology::EANX_CHK}, {"GS1_128", Symbology::GS1_128}, {"CODABAR", Symbology::CODABAR}, {"CODE128", Symbology::CODE128}, {"DPLEIT", Symbology::DPLEIT}, {"DPIDENT", Symbology::DPIDENT}, {"CODE16K", Symbology::CODE16K}, {"CODE49", Symbology::CODE49}, {"CODE93", Symbology::CODE93}, {"FLAT", Symbology::FLAT}, {"DBAR_OMN", Symbology::DBAR_OMN}, {"DBAR_LTD", Symbology::DBAR_LTD}, {"DBAR_EXP", Symbology::DBAR_EXP}, {"TELEPEN", Symbology::TELEPEN}, {"UPCA", Symbology::UPCA}, {"UPCA_CHK", Symbology::UPCA_CHK}, {"UPCE", Symbology::UPCE}, {"UPCE_CHK", Symbology::UPCE_CHK}, {"POSTNET", Symbology::POSTNET}, {"MSI_PLESSEY", Symbology::MSI_PLESSEY}, {"FIM", Symbology::FIM}, {"LOGMARS", Symbology::LOGMARS}, {"PHARMA", Symbology::PHARMA}, {"PZN", Symbology::PZN}, {"PHARMA_TWO", Symbology::PHARMA_TWO}, {"CEPNET", Symbology::CEPNET}, {"PDF417", Symbology::PDF417}, {"PDF417COMP", Symbology::PDF417COMP}, {"MAXICODE", Symbology::MAXICODE}, {"QRCODE", Symbology::QRCODE}, {"CODE128AB", Symbology::CODE128AB}, {"AUSPOST", Symbology::AUSPOST}, {"AUSREPLY", Symbology::AUSREPLY}, {"AUSROUTE", Symbology::AUSROUTE}, {"AUSREDIRECT", Symbology::AUSREDIRECT}, {"ISBNX", Symbology::ISBNX}, {"RM4SCC", Symbology::RM4SCC}, {"DATAMATRIX", Symbology::DATAMATRIX}, {"EAN14", Symbology::EAN14}, {"VIN", Symbology::VIN}, {"CODABLOCKF", Symbology::CODABLOCKF}, {"NVE18", Symbology::NVE18}, {"JAPANPOST", Symbology::JAPANPOST}, {"KOREAPOST", Symbology::KOREAPOST}, {"DBAR_STK", Symbology::DBAR_STK}, {"DBAR_OMNSTK", Symbology::DBAR_OMNSTK}, {"DBAR_EXPSTK", Symbology::DBAR_EXPSTK}, {"PLANET", Symbology::PLANET}, {"MICROPDF417", Symbology::MICROPDF417}, {"USPS_IMAIL", Symbology::USPS_IMAIL}, {"PLESSEY", Symbology::PLESSEY}, {"TELEPEN_NUM", Symbology::TELEPEN_NUM}, {"ITF14", Symbology::ITF14}, {"KIX", Symbology::KIX}, {"AZTEC", Symbology::AZTEC}, {"DAFT", Symbology::DAFT}, {"DPD", Symbology::DPD}, {"MICROQR", Symbology::MICROQR}, {"HIBC_128", Symbology::HIBC_128}, {"HIBC_39", Symbology::HIBC_39}, {"HIBC_DM", Symbology::HIBC_DM}, {"HIBC_QR", Symbology::HIBC_QR}, {"HIBC_PDF", Symbology::HIBC_PDF}, {"HIBC_MICPDF", Symbology::HIBC_MICPDF}, {"HIBC_BLOCKF", Symbology::HIBC_BLOCKF}, {"HIBC_AZTEC", Symbology::HIBC_AZTEC}, {"DOTCODE", Symbology::DOTCODE}, {"HANXIN", Symbology::HANXIN}, {"MAILMARK_2D", Symbology::MAILMARK_2D}, {"UPU_S10", Symbology::UPU_S10}, {"MAILMARK_4S", Symbology::MAILMARK_4S}, {"AZRUNE", Symbology::AZRUNE}, {"CODE32", Symbology::CODE32}, {"EANX_CC", Symbology::EANX_CC}, {"GS1_128_CC", Symbology::GS1_128_CC}, {"DBAR_OMN_CC", Symbology::DBAR_OMN_CC}, {"DBAR_LTD_CC", Symbology::DBAR_LTD_CC}, {"DBAR_EXP_CC", Symbology::DBAR_EXP_CC}, {"UPCA_CC", Symbology::UPCA_CC}, {"UPCE_CC", Symbology::UPCE_CC}, {"DBAR_STK_CC", Symbology::DBAR_STK_CC}, {"DBAR_OMNSTK_CC", Symbology::DBAR_OMNSTK_CC}, {"DBAR_EXPSTK_CC", Symbology::DBAR_EXPSTK_CC}, {"CHANNEL", Symbology::CHANNEL}, {"CODEONE", Symbology::CODEONE}, {"GRIDMATRIX", Symbology::GRIDMATRIX}, {"UPNQR", Symbology::UPNQR}, {"ULTRA", Symbology::ULTRA}, {"RMQR", Symbology::RMQR}, {"BC412", Symbology::BC412}) +P11X_DECLARE_ENUM("OutputOptions", "enum.Flag", {"BARCODE_BIND_TOP", OutputOptions::BARCODE_BIND_TOP}, {"BARCODE_BIND", OutputOptions::BARCODE_BIND}, {"BARCODE_BOX", OutputOptions::BARCODE_BOX}, {"BARCODE_STDOUT", OutputOptions::BARCODE_STDOUT}, {"READER_INIT", OutputOptions::READER_INIT}, {"SMALL_TEXT", OutputOptions::SMALL_TEXT}, {"BOLD_TEXT", OutputOptions::BOLD_TEXT}, {"CMYK_COLOUR", OutputOptions::CMYK_COLOUR}, {"BARCODE_DOTTY_MODE", OutputOptions::BARCODE_DOTTY_MODE}, {"GS1_GS_SEPARATOR", OutputOptions::GS1_GS_SEPARATOR}, {"OUT_BUFFER_INTERMEDIATE", OutputOptions::OUT_BUFFER_INTERMEDIATE}, {"BARCODE_QUIET_ZONES", OutputOptions::BARCODE_QUIET_ZONES}, {"BARCODE_NO_QUIET_ZONES", OutputOptions::BARCODE_NO_QUIET_ZONES}, {"COMPLIANT_HEIGHT", OutputOptions::COMPLIANT_HEIGHT}, {"EANUPC_GUARD_WHITESPACE", OutputOptions::EANUPC_GUARD_WHITESPACE}, {"EMBED_VECTOR_FONT", OutputOptions::EMBED_VECTOR_FONT}) +P11X_DECLARE_ENUM("InputMode", "enum.Flag", {"DATA", InputMode::DATA}, {"UNICODE", InputMode::UNICODE}, {"GS1", InputMode::GS1}, {"ESCAPE", InputMode::ESCAPE}, {"GS1PARENS", InputMode::GS1PARENS}, {"GS1NOCHECK", InputMode::GS1NOCHECK}, {"HEIGHTPERROW", InputMode::HEIGHTPERROW}, {"FAST", InputMode::FAST}, {"EXTRA_ESCAPE", InputMode::EXTRA_ESCAPE}) +P11X_DECLARE_ENUM("DataMatrixOptions", "enum.Enum", {"SQUARE", DataMatrixOptions::SQUARE}, {"DMRE", DataMatrixOptions::DMRE}, {"ISO_144", DataMatrixOptions::ISO_144}) +P11X_DECLARE_ENUM("QrFamilyOptions", "enum.Enum", {"FULL_MULTIBYTE", QrFamilyOptions::FULL_MULTIBYTE}) +P11X_DECLARE_ENUM("UltracodeOptions", "enum.Enum", {"ULTRA_COMPRESSION", UltracodeOptions::ULTRA_COMPRESSION}) +P11X_DECLARE_ENUM("WarningLevel", "enum.Enum", {"DEFAULT", WarningLevel::DEFAULT}, {"FAIL_ALL", WarningLevel::FAIL_ALL}) +P11X_DECLARE_ENUM("CapabilityFlags", "enum.Enum", {"HRT", CapabilityFlags::HRT}, {"STACKABLE", CapabilityFlags::STACKABLE}, {"EANUPC", CapabilityFlags::EANUPC}, {"COMPOSITE", CapabilityFlags::COMPOSITE}, {"ECI", CapabilityFlags::ECI}, {"GS1", CapabilityFlags::GS1}, {"DOTTY", CapabilityFlags::DOTTY}, {"QUIET_ZONES", CapabilityFlags::QUIET_ZONES}, {"FIXED_RATIO", CapabilityFlags::FIXED_RATIO}, {"READER_INIT", CapabilityFlags::READER_INIT}, {"FULL_MULTIBYTE", CapabilityFlags::FULL_MULTIBYTE}, {"MASK", CapabilityFlags::MASK}, {"STRUCTAPP", CapabilityFlags::STRUCTAPP}, {"COMPLIANT_HEIGHT", CapabilityFlags::COMPLIANT_HEIGHT}) + + +#pragma warning(pop) diff --git a/src/zint/src/generated/enums.hpp b/src/zint/src/generated/enums.hpp deleted file mode 100644 index edf15943..00000000 --- a/src/zint/src/generated/enums.hpp +++ /dev/null @@ -1,375 +0,0 @@ -/// This file was generated automatically by scripts/generate-enums.py. Please do not edit it manually. -#pragma once -#include - -namespace py = pybind11; - -enum class Symbology : int { - CODE11 = 1, - C25STANDARD = 2, - C25INTER = 3, - C25IATA = 4, - C25LOGIC = 6, - C25IND = 7, - CODE39 = 8, - EXCODE39 = 9, - EANX = 13, - EANX_CHK = 14, - GS1_128 = 16, - CODABAR = 18, - CODE128 = 20, - DPLEIT = 21, - DPIDENT = 22, - CODE16K = 23, - CODE49 = 24, - CODE93 = 25, - FLAT = 28, - DBAR_OMN = 29, - DBAR_LTD = 30, - DBAR_EXP = 31, - TELEPEN = 32, - UPCA = 34, - UPCA_CHK = 35, - UPCE = 37, - UPCE_CHK = 38, - POSTNET = 40, - MSI_PLESSEY = 47, - FIM = 49, - LOGMARS = 50, - PHARMA = 51, - PZN = 52, - PHARMA_TWO = 53, - CEPNET = 54, - PDF417 = 55, - PDF417COMP = 56, - MAXICODE = 57, - QRCODE = 58, - CODE128AB = 60, - AUSPOST = 63, - AUSREPLY = 66, - AUSROUTE = 67, - AUSREDIRECT = 68, - ISBNX = 69, - RM4SCC = 70, - DATAMATRIX = 71, - EAN14 = 72, - VIN = 73, - CODABLOCKF = 74, - NVE18 = 75, - JAPANPOST = 76, - KOREAPOST = 77, - DBAR_STK = 79, - DBAR_OMNSTK = 80, - DBAR_EXPSTK = 81, - PLANET = 82, - MICROPDF417 = 84, - USPS_IMAIL = 85, - PLESSEY = 86, - TELEPEN_NUM = 87, - ITF14 = 89, - KIX = 90, - AZTEC = 92, - DAFT = 93, - DPD = 96, - MICROQR = 97, - HIBC_128 = 98, - HIBC_39 = 99, - HIBC_DM = 102, - HIBC_QR = 104, - HIBC_PDF = 106, - HIBC_MICPDF = 108, - HIBC_BLOCKF = 110, - HIBC_AZTEC = 112, - DOTCODE = 115, - HANXIN = 116, - MAILMARK_2D = 119, - UPU_S10 = 120, - MAILMARK_4S = 121, - AZRUNE = 128, - CODE32 = 129, - EANX_CC = 130, - GS1_128_CC = 131, - DBAR_OMN_CC = 132, - DBAR_LTD_CC = 133, - DBAR_EXP_CC = 134, - UPCA_CC = 135, - UPCE_CC = 136, - DBAR_STK_CC = 137, - DBAR_OMNSTK_CC = 138, - DBAR_EXPSTK_CC = 139, - CHANNEL = 140, - CODEONE = 141, - GRIDMATRIX = 142, - UPNQR = 143, - ULTRA = 144, - RMQR = 145, - BC412 = 146 -}; -enum class OutputOptions : int { - BARCODE_BIND_TOP = 1, - BARCODE_BIND = 2, - BARCODE_BOX = 4, - BARCODE_STDOUT = 8, - READER_INIT = 16, - SMALL_TEXT = 32, - BOLD_TEXT = 64, - CMYK_COLOUR = 128, - BARCODE_DOTTY_MODE = 256, - GS1_GS_SEPARATOR = 512, - OUT_BUFFER_INTERMEDIATE = 1024, - BARCODE_QUIET_ZONES = 2048, - BARCODE_NO_QUIET_ZONES = 4096, - COMPLIANT_HEIGHT = 8192, - EANUPC_GUARD_WHITESPACE = 16384, - EMBED_VECTOR_FONT = 32768 -}; -enum class InputMode : int { - DATA = 0, - UNICODE = 1, - GS1 = 2, - ESCAPE = 8, - GS1PARENS = 16, - GS1NOCHECK = 32, - HEIGHTPERROW = 64, - FAST = 128, - EXTRA_ESCAPE = 256 -}; -enum class DataMatrixOptions : int { SQUARE = 100, DMRE = 101, ISO_144 = 128 }; -enum class QrFamilyOptions : int { FULL_MULTIBYTE = 200 }; -enum class UltracodeOptions : int { ULTRA_COMPRESSION = 128 }; -enum class WarningLevel : int { DEFAULT = 0, FAIL_ALL = 2 }; -enum class CapabilityFlags : unsigned int { - HRT = 1, - STACKABLE = 2, - EANUPC = 4, - EXTENDABLE = 4, - COMPOSITE = 8, - ECI = 16, - GS1 = 32, - DOTTY = 64, - QUIET_ZONES = 128, - FIXED_RATIO = 256, - READER_INIT = 512, - FULL_MULTIBYTE = 1024, - MASK = 2048, - STRUCTAPP = 4096, - COMPLIANT_HEIGHT = 8192 -}; - -inline void init_enum_bindings(pybind11::module_& m) { - py::enum_(m, "Symbology", "Values for `Symbol.symbology`") - .value("CODE11", Symbology::CODE11, "Code 11") - .value("C25STANDARD", Symbology::C25STANDARD, "2 of 5 Standard (Matrix)") - .value("C25INTER", Symbology::C25INTER, "2 of 5 Interleaved") - .value("C25IATA", Symbology::C25IATA, "2 of 5 IATA") - .value("C25LOGIC", Symbology::C25LOGIC, "2 of 5 Data Logic") - .value("C25IND", Symbology::C25IND, "2 of 5 Industrial") - .value("CODE39", Symbology::CODE39, "Code 39") - .value("EXCODE39", Symbology::EXCODE39, "Extended Code 39") - .value("EANX", Symbology::EANX, "EAN (European Article Number)") - .value("EANX_CHK", Symbology::EANX_CHK, "EAN + Check Digit") - .value("GS1_128", Symbology::GS1_128, "GS1-128") - .value("CODABAR", Symbology::CODABAR, "Codabar") - .value("CODE128", Symbology::CODE128, "Code 128") - .value("DPLEIT", Symbology::DPLEIT, "Deutsche Post Leitcode") - .value("DPIDENT", Symbology::DPIDENT, "Deutsche Post Identcode") - .value("CODE16K", Symbology::CODE16K, "Code 16k") - .value("CODE49", Symbology::CODE49, "Code 49") - .value("CODE93", Symbology::CODE93, "Code 93") - .value("FLAT", Symbology::FLAT, "Flattermarken") - .value("DBAR_OMN", Symbology::DBAR_OMN, "GS1 DataBar Omnidirectional") - .value("DBAR_LTD", Symbology::DBAR_LTD, "GS1 DataBar Limited") - .value("DBAR_EXP", Symbology::DBAR_EXP, "GS1 DataBar Expanded") - .value("TELEPEN", Symbology::TELEPEN, "Telepen Alpha") - .value("UPCA", Symbology::UPCA, "UPC-A") - .value("UPCA_CHK", Symbology::UPCA_CHK, "UPC-A + Check Digit") - .value("UPCE", Symbology::UPCE, "UPC-E") - .value("UPCE_CHK", Symbology::UPCE_CHK, "UPC-E + Check Digit") - .value("POSTNET", Symbology::POSTNET, "USPS (U.S. Postal Service) POSTNET") - .value("MSI_PLESSEY", Symbology::MSI_PLESSEY, "MSI Plessey") - .value("FIM", Symbology::FIM, "Facing Identification Mark") - .value("LOGMARS", Symbology::LOGMARS, "LOGMARS") - .value("PHARMA", Symbology::PHARMA, "Pharmacode One-Track") - .value("PZN", Symbology::PZN, "Pharmazentralnummer") - .value("PHARMA_TWO", Symbology::PHARMA_TWO, "Pharmacode Two-Track") - .value("CEPNET", Symbology::CEPNET, "Brazilian CEPNet Postal Code") - .value("PDF417", Symbology::PDF417, "PDF417") - .value("PDF417COMP", Symbology::PDF417COMP, "Compact PDF417 (Truncated PDF417)") - .value("MAXICODE", Symbology::MAXICODE, "MaxiCode") - .value("QRCODE", Symbology::QRCODE, "QR Code") - .value("CODE128AB", Symbology::CODE128AB, "Code 128 (Suppress Code Set C)") - .value("AUSPOST", Symbology::AUSPOST, "Australia Post Standard Customer") - .value("AUSREPLY", Symbology::AUSREPLY, "Australia Post Reply Paid") - .value("AUSROUTE", Symbology::AUSROUTE, "Australia Post Routing") - .value("AUSREDIRECT", Symbology::AUSREDIRECT, "Australia Post Redirection") - .value("ISBNX", Symbology::ISBNX, "ISBN") - .value("RM4SCC", Symbology::RM4SCC, "Royal Mail 4-State Customer Code") - .value("DATAMATRIX", Symbology::DATAMATRIX, "Data Matrix (ECC200)") - .value("EAN14", Symbology::EAN14, "EAN-14") - .value("VIN", Symbology::VIN, "Vehicle Identification Number") - .value("CODABLOCKF", Symbology::CODABLOCKF, "Codablock-F") - .value("NVE18", Symbology::NVE18, "NVE-18 (SSCC-18)") - .value("JAPANPOST", Symbology::JAPANPOST, "Japanese Postal Code") - .value("KOREAPOST", Symbology::KOREAPOST, "Korea Post") - .value("DBAR_STK", Symbology::DBAR_STK, "GS1 DataBar Stacked") - .value("DBAR_OMNSTK", Symbology::DBAR_OMNSTK, "GS1 DataBar Stacked Omnidirectional") - .value("DBAR_EXPSTK", Symbology::DBAR_EXPSTK, "GS1 DataBar Expanded Stacked") - .value("PLANET", Symbology::PLANET, "USPS PLANET") - .value("MICROPDF417", Symbology::MICROPDF417, "MicroPDF417") - .value("USPS_IMAIL", Symbology::USPS_IMAIL, "USPS Intelligent Mail (OneCode)") - .value("PLESSEY", Symbology::PLESSEY, "UK Plessey") - .value("TELEPEN_NUM", Symbology::TELEPEN_NUM, "Telepen Numeric") - .value("ITF14", Symbology::ITF14, "ITF-14") - .value("KIX", Symbology::KIX, "Dutch Post KIX Code") - .value("AZTEC", Symbology::AZTEC, "Aztec Code") - .value("DAFT", Symbology::DAFT, "DAFT Code") - .value("DPD", Symbology::DPD, "DPD Code") - .value("MICROQR", Symbology::MICROQR, "Micro QR Code") - .value("HIBC_128", Symbology::HIBC_128, "HIBC (Health Industry Barcode) Code 128") - .value("HIBC_39", Symbology::HIBC_39, "HIBC Code 39") - .value("HIBC_DM", Symbology::HIBC_DM, "HIBC Data Matrix") - .value("HIBC_QR", Symbology::HIBC_QR, "HIBC QR Code") - .value("HIBC_PDF", Symbology::HIBC_PDF, "HIBC PDF417") - .value("HIBC_MICPDF", Symbology::HIBC_MICPDF, "HIBC MicroPDF417") - .value("HIBC_BLOCKF", Symbology::HIBC_BLOCKF, "HIBC Codablock-F") - .value("HIBC_AZTEC", Symbology::HIBC_AZTEC, "HIBC Aztec Code") - .value("DOTCODE", Symbology::DOTCODE, "DotCode") - .value("HANXIN", Symbology::HANXIN, "Han Xin (Chinese Sensible) Code") - .value("MAILMARK_2D", Symbology::MAILMARK_2D, "Royal Mail 2D Mailmark (CMDM) (Data Matrix)") - .value("UPU_S10", Symbology::UPU_S10, "Universal Postal Union S10") - .value("MAILMARK_4S", Symbology::MAILMARK_4S, "Royal Mail 4-State Mailmark") - .value("AZRUNE", Symbology::AZRUNE, "Aztec Runes") - .value("CODE32", Symbology::CODE32, "Code 32") - .value("EANX_CC", Symbology::EANX_CC, "EAN Composite") - .value("GS1_128_CC", Symbology::GS1_128_CC, "GS1-128 Composite") - .value("DBAR_OMN_CC", Symbology::DBAR_OMN_CC, "GS1 DataBar Omnidirectional Composite") - .value("DBAR_LTD_CC", Symbology::DBAR_LTD_CC, "GS1 DataBar Limited Composite") - .value("DBAR_EXP_CC", Symbology::DBAR_EXP_CC, "GS1 DataBar Expanded Composite") - .value("UPCA_CC", Symbology::UPCA_CC, "UPC-A Composite") - .value("UPCE_CC", Symbology::UPCE_CC, "UPC-E Composite") - .value("DBAR_STK_CC", Symbology::DBAR_STK_CC, "GS1 DataBar Stacked Composite") - .value("DBAR_OMNSTK_CC", Symbology::DBAR_OMNSTK_CC, "GS1 DataBar Stacked Omnidirectional Composite") - .value("DBAR_EXPSTK_CC", Symbology::DBAR_EXPSTK_CC, "GS1 DataBar Expanded Stacked Composite") - .value("CHANNEL", Symbology::CHANNEL, "Channel Code") - .value("CODEONE", Symbology::CODEONE, "Code One") - .value("GRIDMATRIX", Symbology::GRIDMATRIX, "Grid Matrix") - .value("UPNQR", Symbology::UPNQR, "UPNQR (Univerzalnega Plačilnega Naloga QR)") - .value("ULTRA", Symbology::ULTRA, "Ultracode") - .value("RMQR", Symbology::RMQR, "Rectangular Micro QR Code (rMQR)") - .value("BC412", Symbology::BC412, "IBM BC412 (SEMI T1-95)"); - py::enum_(m, "OutputOptions", py::arithmetic{}, "Values for `Symbol.output_options`") - .value( - "BARCODE_BIND_TOP", - OutputOptions::BARCODE_BIND_TOP, - "Boundary bar above the symbol only (not below), does not affect stacking. Note: value was once used by " - "the legacy (never-used) BARCODE_NO_ASCII" - ) - .value( - "BARCODE_BIND", - OutputOptions::BARCODE_BIND, - "Boundary bars above & below the symbol and between stacked symbols" - ) - .value("BARCODE_BOX", OutputOptions::BARCODE_BOX, "Box around symbol") - .value("BARCODE_STDOUT", OutputOptions::BARCODE_STDOUT, "Output to stdout") - .value("READER_INIT", OutputOptions::READER_INIT, "Reader Initialisation (Programming)") - .value("SMALL_TEXT", OutputOptions::SMALL_TEXT, "Use smaller font") - .value("BOLD_TEXT", OutputOptions::BOLD_TEXT, "Use bold font") - .value("CMYK_COLOUR", OutputOptions::CMYK_COLOUR, "CMYK colour space (Encapsulated PostScript and TIF)") - .value( - "BARCODE_DOTTY_MODE", - OutputOptions::BARCODE_DOTTY_MODE, - "Plot a matrix symbol using dots rather than squares" - ) - .value( - "GS1_GS_SEPARATOR", OutputOptions::GS1_GS_SEPARATOR, "Use GS instead of FNC1 as GS1 separator (Data Matrix)" - ) - .value( - "OUT_BUFFER_INTERMEDIATE", - OutputOptions::OUT_BUFFER_INTERMEDIATE, - "Return ASCII values in bitmap buffer (OUT_BUFFER only)" - ) - .value( - "BARCODE_QUIET_ZONES", - OutputOptions::BARCODE_QUIET_ZONES, - "Add compliant quiet zones (additional to any specified whitespace). Note: CODE16K, CODE49, CODABLOCKF, " - "ITF14, EAN/UPC have default quiet zones" - ) - .value( - "BARCODE_NO_QUIET_ZONES", - OutputOptions::BARCODE_NO_QUIET_ZONES, - "Disable quiet zones, notably those with defaults as listed above" - ) - .value( - "COMPLIANT_HEIGHT", - OutputOptions::COMPLIANT_HEIGHT, - "Warn if height not compliant, or use standard height (if any) as default" - ) - .value( - "EANUPC_GUARD_WHITESPACE", - OutputOptions::EANUPC_GUARD_WHITESPACE, - "Add quiet zone indicators (\"<\"/\">\") to HRT whitespace (EAN/UPC)" - ) - .value( - "EMBED_VECTOR_FONT", - OutputOptions::EMBED_VECTOR_FONT, - "Embed font in vector output - currently only for SVG output" - ); - py::enum_(m, "InputMode", py::arithmetic{}, "Values for `Symbol.input_mode`") - .value("DATA", InputMode::DATA, "Binary") - .value("UNICODE", InputMode::UNICODE, "UTF-8") - .value("GS1", InputMode::GS1, "GS1. The following may be OR-ed with above") - .value("ESCAPE", InputMode::ESCAPE, "Process escape sequences") - .value( - "GS1PARENS", InputMode::GS1PARENS, "Process parentheses as GS1 AI delimiters (instead of square brackets)" - ) - .value( - "GS1NOCHECK", InputMode::GS1NOCHECK, "Do not check validity of GS1 data (except that printable ASCII only)" - ) - .value("HEIGHTPERROW", InputMode::HEIGHTPERROW, "Interpret `height` as per-row rather than as overall height") - .value( - "FAST", - InputMode::FAST, - "Use faster if less optimal encodation or other shortcuts if available. Note: affects DATAMATRIX, " - "MICROPDF417, PDF417, QRCODE & UPNQR only" - ) - .value( - "EXTRA_ESCAPE", - InputMode::EXTRA_ESCAPE, - "Process special symbology-specific escape sequences. Note: currently Code 128 only" - ); - py::enum_(m, "DataMatrixOptions", "Data Matrix specific options (`symbol->option_3`)") - .value("SQUARE", DataMatrixOptions::SQUARE, "Only consider square versions on automatic symbol size selection") - .value("DMRE", DataMatrixOptions::DMRE, "Consider DMRE versions on automatic symbol size selection") - .value( - "ISO_144", - DataMatrixOptions::ISO_144, - "Use ISO instead of \"de facto\" format for 144x144 (i.e. don't skew ECC)" - ); - py::enum_(m, "QrFamilyOptions", "QR, Han Xin, Grid Matrix specific options (`symbol->option_3`)") - .value( - "FULL_MULTIBYTE", - QrFamilyOptions::FULL_MULTIBYTE, - "Enable Kanji/Hanzi compression for Latin-1 & binary data" - ); - py::enum_(m, "UltracodeOptions", "Ultracode specific option (`symbol->option_3`)") - .value("ULTRA_COMPRESSION", UltracodeOptions::ULTRA_COMPRESSION, "Enable Ultracode compression (experimental)"); - py::enum_(m, "WarningLevel", "Warning level (`symbol->warn_level`)") - .value("DEFAULT", WarningLevel::DEFAULT, "Default behaviour") - .value("FAIL_ALL", WarningLevel::FAIL_ALL, "Treat warning as error"); - py::enum_(m, "CapabilityFlags", "Capability flags (ZBarcode_Cap() `cap_flag`)") - .value("HRT", CapabilityFlags::HRT, "Prints Human Readable Text?") - .value("STACKABLE", CapabilityFlags::STACKABLE, "Is stackable?") - .value("EANUPC", CapabilityFlags::EANUPC, "Is EAN/UPC?") - .value("EXTENDABLE", CapabilityFlags::EXTENDABLE, "Legacy") - .value("COMPOSITE", CapabilityFlags::COMPOSITE, "Can have composite data?") - .value("ECI", CapabilityFlags::ECI, "Supports Extended Channel Interpretations?") - .value("GS1", CapabilityFlags::GS1, "Supports GS1 data?") - .value("DOTTY", CapabilityFlags::DOTTY, "Can be output as dots?") - .value("QUIET_ZONES", CapabilityFlags::QUIET_ZONES, "Has default quiet zones?") - .value("FIXED_RATIO", CapabilityFlags::FIXED_RATIO, "Has fixed width-to-height (aspect) ratio?") - .value("READER_INIT", CapabilityFlags::READER_INIT, "Supports Reader Initialisation?") - .value("FULL_MULTIBYTE", CapabilityFlags::FULL_MULTIBYTE, "Supports full-multibyte option?") - .value("MASK", CapabilityFlags::MASK, "Is mask selectable?") - .value("STRUCTAPP", CapabilityFlags::STRUCTAPP, "Supports Structured Append?") - .value("COMPLIANT_HEIGHT", CapabilityFlags::COMPLIANT_HEIGHT, "Has compliant height?"); -} diff --git a/src/zint/src/generated/enums.inc b/src/zint/src/generated/enums.inc new file mode 100644 index 00000000..931bf23b --- /dev/null +++ b/src/zint/src/generated/enums.inc @@ -0,0 +1,169 @@ +ENUM_BEGIN(Symbology, int, "enum.Enum", "Values for `Symbol.symbology`") +ENUM_VALUE(Symbology, CODE11, 1, "Code 11") +ENUM_VALUE(Symbology, C25STANDARD, 2, "2 of 5 Standard (Matrix)") +ENUM_VALUE(Symbology, C25INTER, 3, "2 of 5 Interleaved") +ENUM_VALUE(Symbology, C25IATA, 4, "2 of 5 IATA") +ENUM_VALUE(Symbology, C25LOGIC, 6, "2 of 5 Data Logic") +ENUM_VALUE(Symbology, C25IND, 7, "2 of 5 Industrial") +ENUM_VALUE(Symbology, CODE39, 8, "Code 39") +ENUM_VALUE(Symbology, EXCODE39, 9, "Extended Code 39") +ENUM_VALUE(Symbology, EANX, 13, "EAN (European Article Number)") +ENUM_VALUE(Symbology, EANX_CHK, 14, "EAN + Check Digit") +ENUM_VALUE(Symbology, GS1_128, 16, "GS1-128") +ENUM_VALUE(Symbology, CODABAR, 18, "Codabar") +ENUM_VALUE(Symbology, CODE128, 20, "Code 128") +ENUM_VALUE(Symbology, DPLEIT, 21, "Deutsche Post Leitcode") +ENUM_VALUE(Symbology, DPIDENT, 22, "Deutsche Post Identcode") +ENUM_VALUE(Symbology, CODE16K, 23, "Code 16k") +ENUM_VALUE(Symbology, CODE49, 24, "Code 49") +ENUM_VALUE(Symbology, CODE93, 25, "Code 93") +ENUM_VALUE(Symbology, FLAT, 28, "Flattermarken") +ENUM_VALUE(Symbology, DBAR_OMN, 29, "GS1 DataBar Omnidirectional") +ENUM_VALUE(Symbology, DBAR_LTD, 30, "GS1 DataBar Limited") +ENUM_VALUE(Symbology, DBAR_EXP, 31, "GS1 DataBar Expanded") +ENUM_VALUE(Symbology, TELEPEN, 32, "Telepen Alpha") +ENUM_VALUE(Symbology, UPCA, 34, "UPC-A") +ENUM_VALUE(Symbology, UPCA_CHK, 35, "UPC-A + Check Digit") +ENUM_VALUE(Symbology, UPCE, 37, "UPC-E") +ENUM_VALUE(Symbology, UPCE_CHK, 38, "UPC-E + Check Digit") +ENUM_VALUE(Symbology, POSTNET, 40, "USPS (U.S. Postal Service) POSTNET") +ENUM_VALUE(Symbology, MSI_PLESSEY, 47, "MSI Plessey") +ENUM_VALUE(Symbology, FIM, 49, "Facing Identification Mark") +ENUM_VALUE(Symbology, LOGMARS, 50, "LOGMARS") +ENUM_VALUE(Symbology, PHARMA, 51, "Pharmacode One-Track") +ENUM_VALUE(Symbology, PZN, 52, "Pharmazentralnummer") +ENUM_VALUE(Symbology, PHARMA_TWO, 53, "Pharmacode Two-Track") +ENUM_VALUE(Symbology, CEPNET, 54, "Brazilian CEPNet Postal Code") +ENUM_VALUE(Symbology, PDF417, 55, "PDF417") +ENUM_VALUE(Symbology, PDF417COMP, 56, "Compact PDF417 (Truncated PDF417)") +ENUM_VALUE(Symbology, MAXICODE, 57, "MaxiCode") +ENUM_VALUE(Symbology, QRCODE, 58, "QR Code") +ENUM_VALUE(Symbology, CODE128AB, 60, "Code 128 (Suppress Code Set C)") +ENUM_VALUE(Symbology, AUSPOST, 63, "Australia Post Standard Customer") +ENUM_VALUE(Symbology, AUSREPLY, 66, "Australia Post Reply Paid") +ENUM_VALUE(Symbology, AUSROUTE, 67, "Australia Post Routing") +ENUM_VALUE(Symbology, AUSREDIRECT, 68, "Australia Post Redirection") +ENUM_VALUE(Symbology, ISBNX, 69, "ISBN") +ENUM_VALUE(Symbology, RM4SCC, 70, "Royal Mail 4-State Customer Code") +ENUM_VALUE(Symbology, DATAMATRIX, 71, "Data Matrix (ECC200)") +ENUM_VALUE(Symbology, EAN14, 72, "EAN-14") +ENUM_VALUE(Symbology, VIN, 73, "Vehicle Identification Number") +ENUM_VALUE(Symbology, CODABLOCKF, 74, "Codablock-F") +ENUM_VALUE(Symbology, NVE18, 75, "NVE-18 (SSCC-18)") +ENUM_VALUE(Symbology, JAPANPOST, 76, "Japanese Postal Code") +ENUM_VALUE(Symbology, KOREAPOST, 77, "Korea Post") +ENUM_VALUE(Symbology, DBAR_STK, 79, "GS1 DataBar Stacked") +ENUM_VALUE(Symbology, DBAR_OMNSTK, 80, "GS1 DataBar Stacked Omnidirectional") +ENUM_VALUE(Symbology, DBAR_EXPSTK, 81, "GS1 DataBar Expanded Stacked") +ENUM_VALUE(Symbology, PLANET, 82, "USPS PLANET") +ENUM_VALUE(Symbology, MICROPDF417, 84, "MicroPDF417") +ENUM_VALUE(Symbology, USPS_IMAIL, 85, "USPS Intelligent Mail (OneCode)") +ENUM_VALUE(Symbology, PLESSEY, 86, "UK Plessey") +ENUM_VALUE(Symbology, TELEPEN_NUM, 87, "Telepen Numeric") +ENUM_VALUE(Symbology, ITF14, 89, "ITF-14") +ENUM_VALUE(Symbology, KIX, 90, "Dutch Post KIX Code") +ENUM_VALUE(Symbology, AZTEC, 92, "Aztec Code") +ENUM_VALUE(Symbology, DAFT, 93, "DAFT Code") +ENUM_VALUE(Symbology, DPD, 96, "DPD Code") +ENUM_VALUE(Symbology, MICROQR, 97, "Micro QR Code") +ENUM_VALUE(Symbology, HIBC_128, 98, "HIBC (Health Industry Barcode) Code 128") +ENUM_VALUE(Symbology, HIBC_39, 99, "HIBC Code 39") +ENUM_VALUE(Symbology, HIBC_DM, 102, "HIBC Data Matrix") +ENUM_VALUE(Symbology, HIBC_QR, 104, "HIBC QR Code") +ENUM_VALUE(Symbology, HIBC_PDF, 106, "HIBC PDF417") +ENUM_VALUE(Symbology, HIBC_MICPDF, 108, "HIBC MicroPDF417") +ENUM_VALUE(Symbology, HIBC_BLOCKF, 110, "HIBC Codablock-F") +ENUM_VALUE(Symbology, HIBC_AZTEC, 112, "HIBC Aztec Code") +ENUM_VALUE(Symbology, DOTCODE, 115, "DotCode") +ENUM_VALUE(Symbology, HANXIN, 116, "Han Xin (Chinese Sensible) Code") +ENUM_VALUE(Symbology, MAILMARK_2D, 119, "Royal Mail 2D Mailmark (CMDM) (Data Matrix)") +ENUM_VALUE(Symbology, UPU_S10, 120, "Universal Postal Union S10") +ENUM_VALUE(Symbology, MAILMARK_4S, 121, "Royal Mail 4-State Mailmark") +ENUM_VALUE(Symbology, AZRUNE, 128, "Aztec Runes") +ENUM_VALUE(Symbology, CODE32, 129, "Code 32") +ENUM_VALUE(Symbology, EANX_CC, 130, "EAN Composite") +ENUM_VALUE(Symbology, GS1_128_CC, 131, "GS1-128 Composite") +ENUM_VALUE(Symbology, DBAR_OMN_CC, 132, "GS1 DataBar Omnidirectional Composite") +ENUM_VALUE(Symbology, DBAR_LTD_CC, 133, "GS1 DataBar Limited Composite") +ENUM_VALUE(Symbology, DBAR_EXP_CC, 134, "GS1 DataBar Expanded Composite") +ENUM_VALUE(Symbology, UPCA_CC, 135, "UPC-A Composite") +ENUM_VALUE(Symbology, UPCE_CC, 136, "UPC-E Composite") +ENUM_VALUE(Symbology, DBAR_STK_CC, 137, "GS1 DataBar Stacked Composite") +ENUM_VALUE(Symbology, DBAR_OMNSTK_CC, 138, "GS1 DataBar Stacked Omnidirectional Composite") +ENUM_VALUE(Symbology, DBAR_EXPSTK_CC, 139, "GS1 DataBar Expanded Stacked Composite") +ENUM_VALUE(Symbology, CHANNEL, 140, "Channel Code") +ENUM_VALUE(Symbology, CODEONE, 141, "Code One") +ENUM_VALUE(Symbology, GRIDMATRIX, 142, "Grid Matrix") +ENUM_VALUE(Symbology, UPNQR, 143, "UPNQR (Univerzalnega Plačilnega Naloga QR)") +ENUM_VALUE(Symbology, ULTRA, 144, "Ultracode") +ENUM_VALUE(Symbology, RMQR, 145, "Rectangular Micro QR Code (rMQR)") +ENUM_VALUE(Symbology, BC412, 146, "IBM BC412 (SEMI T1-95)") +ENUM_END(Symbology) + +ENUM_BEGIN(OutputOptions, int, "enum.Flag", "Values for `Symbol.output_options`") +ENUM_VALUE(OutputOptions, BARCODE_BIND_TOP, 1, "Boundary bar above the symbol only (not below), does not affect stacking. Note: value was once used by the legacy (never-used) BARCODE_NO_ASCII") +ENUM_VALUE(OutputOptions, BARCODE_BIND, 2, "Boundary bars above & below the symbol and between stacked symbols") +ENUM_VALUE(OutputOptions, BARCODE_BOX, 4, "Box around symbol") +ENUM_VALUE(OutputOptions, BARCODE_STDOUT, 8, "Output to stdout") +ENUM_VALUE(OutputOptions, READER_INIT, 16, "Reader Initialisation (Programming)") +ENUM_VALUE(OutputOptions, SMALL_TEXT, 32, "Use smaller font") +ENUM_VALUE(OutputOptions, BOLD_TEXT, 64, "Use bold font") +ENUM_VALUE(OutputOptions, CMYK_COLOUR, 128, "CMYK colour space (Encapsulated PostScript and TIF)") +ENUM_VALUE(OutputOptions, BARCODE_DOTTY_MODE, 256, "Plot a matrix symbol using dots rather than squares") +ENUM_VALUE(OutputOptions, GS1_GS_SEPARATOR, 512, "Use GS instead of FNC1 as GS1 separator (Data Matrix)") +ENUM_VALUE(OutputOptions, OUT_BUFFER_INTERMEDIATE, 1024, "Return ASCII values in bitmap buffer (OUT_BUFFER only)") +ENUM_VALUE(OutputOptions, BARCODE_QUIET_ZONES, 2048, "Add compliant quiet zones (additional to any specified whitespace). Note: CODE16K, CODE49, CODABLOCKF, ITF14, EAN/UPC have default quiet zones") +ENUM_VALUE(OutputOptions, BARCODE_NO_QUIET_ZONES, 4096, "Disable quiet zones, notably those with defaults as listed above") +ENUM_VALUE(OutputOptions, COMPLIANT_HEIGHT, 8192, "Warn if height not compliant, or use standard height (if any) as default") +ENUM_VALUE(OutputOptions, EANUPC_GUARD_WHITESPACE, 16384, "Add quiet zone indicators (\"<\"/\">\") to HRT whitespace (EAN/UPC)") +ENUM_VALUE(OutputOptions, EMBED_VECTOR_FONT, 32768, "Embed font in vector output - currently only for SVG output") +ENUM_END(OutputOptions) + +ENUM_BEGIN(InputMode, int, "enum.Flag", "Values for `Symbol.input_mode`") +ENUM_VALUE(InputMode, DATA, 0, "Binary") +ENUM_VALUE(InputMode, UNICODE, 1, "UTF-8") +ENUM_VALUE(InputMode, GS1, 2, "GS1. The following may be OR-ed with above") +ENUM_VALUE(InputMode, ESCAPE, 8, "Process escape sequences") +ENUM_VALUE(InputMode, GS1PARENS, 16, "Process parentheses as GS1 AI delimiters (instead of square brackets)") +ENUM_VALUE(InputMode, GS1NOCHECK, 32, "Do not check validity of GS1 data (except that printable ASCII only)") +ENUM_VALUE(InputMode, HEIGHTPERROW, 64, "Interpret `height` as per-row rather than as overall height") +ENUM_VALUE(InputMode, FAST, 128, "Use faster if less optimal encodation or other shortcuts if available. Note: affects DATAMATRIX, MICROPDF417, PDF417, QRCODE & UPNQR only") +ENUM_VALUE(InputMode, EXTRA_ESCAPE, 256, "Process special symbology-specific escape sequences. Note: currently Code 128 only") +ENUM_END(InputMode) + +ENUM_BEGIN(DataMatrixOptions, int, "enum.Enum", "Data Matrix specific options (`symbol->option_3`)") +ENUM_VALUE(DataMatrixOptions, SQUARE, 100, "Only consider square versions on automatic symbol size selection") +ENUM_VALUE(DataMatrixOptions, DMRE, 101, "Consider DMRE versions on automatic symbol size selection") +ENUM_VALUE(DataMatrixOptions, ISO_144, 128, "Use ISO instead of \"de facto\" format for 144x144 (i.e. don't skew ECC)") +ENUM_END(DataMatrixOptions) + +ENUM_BEGIN(QrFamilyOptions, int, "enum.Enum", "QR, Han Xin, Grid Matrix specific options (`symbol->option_3`)") +ENUM_VALUE(QrFamilyOptions, FULL_MULTIBYTE, 200, "Enable Kanji/Hanzi compression for Latin-1 & binary data") +ENUM_END(QrFamilyOptions) + +ENUM_BEGIN(UltracodeOptions, int, "enum.Enum", "Ultracode specific option (`symbol->option_3`)") +ENUM_VALUE(UltracodeOptions, ULTRA_COMPRESSION, 128, "Enable Ultracode compression (experimental)") +ENUM_END(UltracodeOptions) + +ENUM_BEGIN(WarningLevel, int, "enum.Enum", "Warning level (`symbol->warn_level`)") +ENUM_VALUE(WarningLevel, DEFAULT, 0, "Default behaviour") +ENUM_VALUE(WarningLevel, FAIL_ALL, 2, "Treat warning as error") +ENUM_END(WarningLevel) + +ENUM_BEGIN(CapabilityFlags, unsigned int, "enum.Enum", "Capability flags (ZBarcode_Cap() `cap_flag`)") +ENUM_VALUE(CapabilityFlags, HRT, 1, "Prints Human Readable Text?") +ENUM_VALUE(CapabilityFlags, STACKABLE, 2, "Is stackable?") +ENUM_VALUE(CapabilityFlags, EANUPC, 4, "Is EAN/UPC?") +ENUM_VALUE(CapabilityFlags, COMPOSITE, 8, "Can have composite data?") +ENUM_VALUE(CapabilityFlags, ECI, 16, "Supports Extended Channel Interpretations?") +ENUM_VALUE(CapabilityFlags, GS1, 32, "Supports GS1 data?") +ENUM_VALUE(CapabilityFlags, DOTTY, 64, "Can be output as dots?") +ENUM_VALUE(CapabilityFlags, QUIET_ZONES, 128, "Has default quiet zones?") +ENUM_VALUE(CapabilityFlags, FIXED_RATIO, 256, "Has fixed width-to-height (aspect) ratio?") +ENUM_VALUE(CapabilityFlags, READER_INIT, 512, "Supports Reader Initialisation?") +ENUM_VALUE(CapabilityFlags, FULL_MULTIBYTE, 1024, "Supports full-multibyte option?") +ENUM_VALUE(CapabilityFlags, MASK, 2048, "Is mask selectable?") +ENUM_VALUE(CapabilityFlags, STRUCTAPP, 4096, "Supports Structured Append?") +ENUM_VALUE(CapabilityFlags, COMPLIANT_HEIGHT, 8192, "Has compliant height?") +ENUM_END(CapabilityFlags) + diff --git a/src/zint/src/main.cpp b/src/zint/src/main.cpp index ead5442c..c459128a 100644 --- a/src/zint/src/main.cpp +++ b/src/zint/src/main.cpp @@ -11,7 +11,7 @@ #include #include -#include "generated/enums.hpp" +#include "enums.hpp" #include "utility.hpp" #include @@ -302,8 +302,8 @@ struct Symbol { void set_show_hrt(bool val) { m_handle->show_hrt = val; } bool get_show_hrt() { return m_handle->show_hrt; } - void set_input_mode(int val) { m_handle->input_mode = val; } - int get_input_mode() { return m_handle->input_mode; } + void set_input_mode(InputMode val) { m_handle->input_mode = static_cast(val); } + InputMode get_input_mode() { return static_cast(m_handle->input_mode); } void set_eci(int val) { m_handle->eci = val; } int get_eci() { return m_handle->eci; } @@ -430,7 +430,7 @@ PYBIND11_MODULE(PACKAGE_NAME, m) { ); }(); - init_enum_bindings(m); + p11x::bind_enums(m); // clang-format off py::class_(m, "VectorRect") diff --git a/tests/test_stub.py b/tests/test_stub.py index 2b74641a..457b6647 100644 --- a/tests/test_stub.py +++ b/tests/test_stub.py @@ -16,8 +16,9 @@ r"zint\.\w+\.__init__ is inconsistent, stub does not have \*args argument \"args\"", # Filtered out because this error is raised for class which are not constructible from Python and don't have an # __init__ in the stub file. - r"zint\.__all__ is not present at runtime", - # Filtered out because __all__ is a special variable and does not need to be present in the file. + r"zint\.InputMode\.DATA is not present in stub", + # Filtered out because of a bug in pybind11-stubgen, tracked in + # https://github.com/sizmailov/pybind11-stubgen/issues/223 ] for i, pattern in enumerate(allowed_errors):